public AdapterManager(string zoneId, List <object> data)
        {
            _zoneId = zoneId;
            foreach (object temp in data)
            {
                if (temp != null)
                {
                    Dictionary <string, object> adapterConfig = (Dictionary <string, object>)temp;
                    string adapterId = (string)adapterConfig["id"];
                    string nameSpace = (string)adapterConfig["namespace"];
                    string className = (string)adapterConfig["className"];
                    Dictionary <string, object> parameters = Utils.Optional <Dictionary <string, object> >(adapterConfig, "parameters");
                    long refreshAdPlanFreq = (long)adapterConfig["refreshAdPlanFreq"];

                    Type adapterType = Type.GetType(nameSpace + "." + className);
                    if (adapterType != null)
                    {
                        Adapter adapter = (Adapter)Activator.CreateInstance(adapterType, new object[] { adapterId });

                        adapter.Subscribe(Adapter.EventType.adAvailable, (object sender, EventArgs e) => {
                            Event.EventManager.sendMediationHasFillEvent(Engine.Instance.AppId, zoneId, adapterId);
                        });

                        adapter.Initialize(zoneId, adapterId, parameters);
                        _adapters.Add(new KeyValuePair <string, Adapter>(adapterId, adapter));
                        _adapterIntervals.Add(adapterId, null);
                        _adapterRefreshFreqs.Add(adapterId, new KeyValuePair <long, long>((long)Math.Round(Time.realtimeSinceStartup), refreshAdPlanFreq));
                        _adapterConsumeTimes.Add(adapterId, new List <long>());
                    }
                }
            }
        }
Exemple #2
0
        public void Show(string zoneId, ShowOptions options)
        {
            if (!_initialized)
            {
                if (options.resultCallback != null)
                {
                    options.resultCallback(ShowResult.Failed);
                }
                return;
            }

            if (!ConfigManager.Instance.IsReady())
            {
                if (ConfigManager.Instance.globalIntervals != null)
                {
                    Event.EventManager.sendMediationCappedEvent(Engine.Instance.AppId, null, "global", ConfigManager.Instance.globalIntervals.NextAvailable());
                }
                if (options.resultCallback != null)
                {
                    options.resultCallback(ShowResult.Failed);
                }
                return;
            }

            Zone zone = ZoneManager.Instance.GetZone(zoneId);

            if (zone == null)
            {
                if (options.resultCallback != null)
                {
                    options.resultCallback(ShowResult.Failed);
                }
                return;
            }

            Adapter adapter = zone.SelectAdapter();

            if (adapter == null)
            {
                if (options.resultCallback != null)
                {
                    options.resultCallback(ShowResult.Failed);
                }
                return;
            }

            Utils.LogDebug("Consuming global ad slot");
            ConfigManager.Instance.globalIntervals.Consume();

            if (ConfigManager.Instance.globalIntervals.IsEmpty())
            {
                Utils.LogDebug("Global ad interval list empty");
                ConfigManager.Instance.RequestAdSources();
            }

            EventHandler finishedHandler = null;
            EventHandler skippedHandler  = null;
            EventHandler failedHandler   = null;

            EventHandler closeHandler = null;

            closeHandler = (object sender, EventArgs e) => {
                _isShowing = false;
                adapter.Unsubscribe(Adapter.EventType.adDidClose, closeHandler);

                if (finishedHandler != null)
                {
                    adapter.Unsubscribe(Adapter.EventType.adFinished, finishedHandler);
                }
                if (skippedHandler != null)
                {
                    adapter.Unsubscribe(Adapter.EventType.adSkipped, skippedHandler);
                }
                if (failedHandler != null)
                {
                    adapter.Unsubscribe(Adapter.EventType.error, failedHandler);
                }
            };
            adapter.Subscribe(Adapter.EventType.adDidClose, closeHandler);

            if (options != null)
            {
                if (options.pause)
                {
                    EventHandler showHandler = null;
                    showHandler = (object sender, EventArgs e) => {
                        PauseGame();
                        adapter.Unsubscribe(Adapter.EventType.adWillOpen, showHandler);
                    };
                    adapter.Subscribe(Adapter.EventType.adWillOpen, showHandler);
                }

                finishedHandler = (object sender, EventArgs e) => {
                    _isShowing = false;
                    if (options.resultCallback != null)
                    {
                        options.resultCallback(ShowResult.Finished);
                    }
                    if (options.pause)
                    {
                        ResumeGame();
                    }
                    adapter.Unsubscribe(Adapter.EventType.adFinished, finishedHandler);
                    finishedHandler = null;
                };
                adapter.Subscribe(Adapter.EventType.adFinished, finishedHandler);

                skippedHandler = (object sender, EventArgs e) => {
                    _isShowing = false;
                    if (options.resultCallback != null)
                    {
                        options.resultCallback(ShowResult.Skipped);
                    }
                    if (options.pause)
                    {
                        ResumeGame();
                    }
                    adapter.Unsubscribe(Adapter.EventType.adSkipped, skippedHandler);
                    skippedHandler = null;
                };
                adapter.Subscribe(Adapter.EventType.adSkipped, skippedHandler);

                failedHandler = (object sender, EventArgs e) => {
                    _isShowing = false;
                    if (options.resultCallback != null)
                    {
                        options.resultCallback(ShowResult.Failed);
                    }
                    if (options.pause)
                    {
                        ResumeGame();
                    }
                    adapter.Unsubscribe(Adapter.EventType.error, failedHandler);
                    failedHandler = null;
                };
                adapter.Subscribe(Adapter.EventType.error, failedHandler);
            }

            Event.EventManager.sendMediationShowEvent(AppId, zone.Id, adapter.Id);
            adapter.Show(zone.Id, adapter.Id, options);
            _isShowing = true;
        }