public MediaContainer GetStream(IProvider prov)
        {
            if (MediaContainer.Childrens.Count > 0 && MediaContainer.Childrens[0].Type == "movie")
            {
                MediaContainer.ViewGroup = null;
                MediaContainer.ViewMode = null;
            }
            bool removeandroid = false;

            if (WebOperationContext.Current != null &&
                WebOperationContext.Current.IncomingRequest.Headers.AllKeys.Contains("X-Plex-Product"))
            {
                //Fix for android hang, if the type is populated
                string kh = WebOperationContext.Current.IncomingRequest.Headers.Get("X-Plex-Product").ToUpper();
                if (kh.Contains("ANDROID"))
                    removeandroid = true;
            }
            MediaContainer.Childrens.ForEach(a =>
            {
                a.Group = null;
                if (removeandroid)
                    a.Type = null;
            });
            return MediaContainer;
        }

        public Layer(string name, string title, IGridSet gridset,IProvider provider, ICache cache = null, ITileFilter cacheFilter = null)
        {
            // Set name
            if (string.IsNullOrEmpty(name))
                throw new ArgumentNullException("Layer Name cannot be null");
            this._name = name;

            // Set title
            this._title = title;

            // Set GridSet
            if (gridset == null)
                throw new ArgumentNullException("Layer GridSet cannot be null");
            this._gridSet = gridset;

            // Set Cache
            this._cache = cache;

            // Set Provider
            if (provider == null)
                throw new ArgumentNullException("Layer Provider cannot be null");
            this._provider = provider;

            this._cacheFitler = cacheFilter;
        }

 public UnitOfWork(IProvider dataProvider)
 {
     provider = dataProvider as Provider;
     if (provider == null)
         throw new Exception("Invalid Data Provider");
     transaction = provider.Session.BeginTransaction();
 }

 public ProviderNode(IProvider provider)
 {
   this.provider = provider;
   this.Text = provider.Name;
   this.ToolTipText = string.Format("{0}{1}{2}", provider.Title, Environment.NewLine, provider.URL);
   this.UpdateStatus();
 }

        static Provider()
        {
            lock (typeof (Provider)) {
                if (provider != null) {
                    return;
                }

                var extensions = GetOrderedExtensions (
                    "/Banshee/Platform/IOProvider",
                    ProviderConfiguration.ProviderSchema.Get (),
                    "Banshee.IO.Gio.Provider", "Banshee.IO.Unix.Provider", "Banshee.IO.SystemIO.Provider"
                );

                foreach (var node in extensions) {
                    try {
                        provider = (IProvider)node.CreateInstance (typeof (IProvider));
                        break;
                    } catch (Exception e) {
                        Log.Warning ("IO provider extension failed to load", e.Message);
                    }
                }

                if (provider == null) {
                    provider = new Banshee.IO.SystemIO.Provider ();
                }

                Log.DebugFormat ("IO provider extension loaded ({0})", provider.GetType ().FullName);

                directory = (IDirectory)Activator.CreateInstance (provider.DirectoryProvider);
                file = (IFile)Activator.CreateInstance (provider.FileProvider);
            }
        }

		public IExecuteResult Execute(IProvider provider, object[] parentArgs, object[] userArgs)
		{
			if(parentArgs == null && !(this.parameters == null || this.parameters.Count == 0))
			{
				throw Error.ArgumentNull("arguments");
			}

			// construct new copy of query info
			List<SqlParameterInfo> spis = new List<SqlParameterInfo>(this.queryInfo.Parameters);

			// add call arguments
			for(int i = 0, n = this.parameters.Count; i < n; i++)
			{
				spis.Add(new SqlParameterInfo(this.parameters[i], parentArgs[i]));
			}

			QueryInfo qi = new QueryInfo(
				this.queryInfo.Query,
				this.queryInfo.CommandText,
				spis.AsReadOnly(),
				this.queryInfo.ResultShape,
				this.queryInfo.ResultType
				);

			// execute query
			return provider.Execute(null, qi, this.factory, parentArgs, userArgs, subQueries, null);
		}

    private HtmlGenericControl constructControl(IProvider provider)
    {
        string iconPath = Utility.GetSocialAuthConfiguration().IconFolder.Path ;
        if (string.IsNullOrEmpty(iconPath))
            iconPath = "images/socialauthicons/";
        iconPath += provider.ProviderType.ToString() + ".png";
        bool isconnected = SocialAuthUser.IsConnectedWith(provider.ProviderType);
        bool iscurrent = (SocialAuthUser.CurrentProvider == provider.ProviderType);
        HtmlGenericControl providerDiv = new HtmlGenericControl("div");
        providerDiv.Attributes.Add("class", "provider");
        ImageButton imgB = new ImageButton()
        {
            ID = "img" + provider.ProviderType,
            CommandArgument = provider.ProviderType.ToString(),
            ImageUrl = iconPath
        };
        if (isconnected)
        {
            HtmlGenericControl tickspan = new HtmlGenericControl("span");
            tickspan.InnerHtml = "<img src='images/socialauthicons/" + (iscurrent ? "currentyes" : "yes") + ".png' style='top:0px;left:0px;z-index:100'/>";
            tickspan.Style.Add("position", "absolute");

            providerDiv.Controls.Add(tickspan);
        }
        //if (iscurrent)
        //    imgB.Style.Add("border", "1px solid yellow");
        imgB.Command += new CommandEventHandler(imgB_Command);
        providerDiv.Controls.Add(imgB);
        return providerDiv;
    }

        public static bool Register(IProvider provider)
        {
            bool retval = false;
            if (provider != null)
            {
                object o = null;
                if (provider.GetItem(typeof(IUserDao), out o))
                {
                    _userDao = o as IUserDao;
                    retval = true;
                }

                if (provider.GetItem(typeof(IQueueDao), out o))
                {
                    _queueDao = o as IQueueDao;
                    retval = true;
                }

                if (!retval)
                {
                    Trace.WriteLine("AdminRegistry.Register(" + provider + "): no daos found");
                }
            }
            else
            {
                Trace.WriteLine("QuestionaireRegistry.Register(" + provider + "): provider was null");
            }
            return retval;
        }

		public void Connect(IProvider provider)
		{
			if (provider.IsConnected)
				return;
			if (this.useMessageLoop)
			{
				this.form.BeginInvoke((Action)(() => provider.Connect()));
				if ((int)provider.Id == 1 || (int)provider.Id == 2)
				{
					ProviderManager.WaitConnected(provider, (int)this.ConnectionTimeout.TotalMilliseconds);
				}
				else
				{
					ProviderHelperForm f = new ProviderHelperForm();
					f.Init(provider, (int)this.ConnectionTimeout.TotalSeconds);
					MethodInvoker methodInvoker = (MethodInvoker)(() =>
					{
						int temp_75 = (int)f.ShowDialog((IWin32Window)this.parentForm);
						f.Dispose();
					});
					if (this.parentForm.InvokeRequired)
						this.parentForm.Invoke((Delegate)methodInvoker);
					else
						methodInvoker();
				}
			}
			else
				provider.Connect((int)this.ConnectionTimeout.TotalMilliseconds);
		}

 internal ConnectionManager(IProvider provider, DbConnection con, int maxUsers, bool disposeConnection) {
     this.provider = provider;
     this.connection = con;
     this.maxUsers = maxUsers;
     this.users = new List<IConnectionUser>(maxUsers);
     this.disposeConnection = disposeConnection;
 }

 public EventMonitorWindow()
 {
     this.InitializeComponent();
     this.counter = new TotalCounter();
     this.providerCounterRows = new Dictionary<IProvider, ProviderCounterViewRow>();
     this.instrumentCounterRows = new Dictionary<IFIXInstrument, InstrumentCounterViewRow>();
     this.selectedProvider = (IProvider)null;
 }

 public static Layer CreateCountryLayer(IProvider countrySource)
 {
     var countries = new Layer("Countries");
     countries.DataSource = countrySource;
     countries.DataSource.SRID = 3785;
     countries.Styles.Add(CreateCountryTheme());
     return countries;
 }

        public override bool Subscribe(IProvider provider, Hashtable parameterMap)
#endif
 {
			bool success = base.Subscribe(provider, parameterMap);
			if (success)
				FireProviderConnectionEvent(provider, PipeConnectionEvent.PROVIDER_CONNECT_PUSH, parameterMap);
			return success;
		}

 public IEnumerable<string> ToSql(IProvider provider, IRuntimeContext context)
 {
     return provider.AlterColumn(Parent.Parent.TableName, new Column(
         Parent.ColumnName,
         new DataType(_type, Size, Scale),
         _isNullable,
         DefaultValue));
 }

 internal SqlConnectionManager(IProvider provider, DbConnection con, int maxUsers, bool disposeConnection) {
     this.provider = provider;
     this.connection = con;
     this.maxUsers = maxUsers;
     this.infoMessagehandler = new SqlInfoMessageEventHandler(this.OnInfoMessage);
     this.users = new List<IConnectionUser>(maxUsers);
     this.disposeConnection = disposeConnection;
 }

        public ProviderInfo(IProvider provider, IProviderMetadata metadata)
        {
            if (provider == null) throw new ArgumentNullException("provider");
            if (metadata == null) throw new ArgumentNullException("metadata");

            Provider = provider;
            Metadata = metadata;
        }

        public void Add(IProvider provider)
        {
            provider.CreateThread = false;
            provider.Disposed += provider_Disposed;

            lock (_providers)
                _providers.Add(provider);
        }

 /// <summary>
 /// Creates an instance of this class
 /// </summary>
 /// <param name="provider">The provider</param>
 /// <param name="heatValueColumn">The name of the column that contains the heat value</param>
 /// <param name="heatValueScale">A value that is responsible to scale the heat value to the range &#x211d;[0, 1f]</param>
 public HeatLayer(IProvider provider, string heatValueColumn, float heatValueScale = 1f)
     : this()
 {
     DataSource = provider;
     HeatValueComputer = GetHeatValueFromColumn;
     HeatValueColumn = heatValueColumn;
     HeatValueScale = heatValueScale;
 }

 /// <summary>
 /// Construcor, initializes the Connector object.
 /// </summary>
 internal Connector(IProvider provider, bool Shared)
 {
     Provider = provider;
     _Shared = Shared;
     Pooled = true;
     InstanceCounter++;
     InstanceNumber = InstanceCounter;
 }

 public ProviderProxy(IProvider provider)
 {
     if (provider == null)
     {
         throw new ArgumentNullException("provider");
     }
     _provider = provider;
 }