CrowdControl/Assets/GleyPlugins/Ads/Scripts/SupportedAdvertisers/CustomMoPub.cs

namespace GleyMobileAds
{
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using UnityEngine;
    using UnityEngine.Events;

    public class CustomMoPub : MonoBehaviour, ICustomAds
    {
#if USE_MOPUB
        private const float reloadTime = 30;
        private readonly int maxRetryCount = 10;

        private bool debug;
        private string bannerAdUnit;
        private string interstitialAdUnit;
        private string rewardedVideoAdUnit;
        private bool bannerUsed;
        private UnityAction<bool, BannerPosition, BannerType> DisplayResult;
        private BannerPosition position;
        private BannerType bannerType;
        private bool initialized;
        private UserConsent consent;
        private UserConsent ccpaConsent;
        private UnityAction OnInterstitialClosed;
        private UnityAction<string> OnInterstitialClosedWithAdvertiser;
        private int currentRetryInterstitial;
        private int currentRetryRewardedVideo;
        private bool rewardedVideoAvailable;
        private UnityAction<bool> OnCompleteMethod;
        private UnityAction<bool, string> OnCompleteMethodWithAdvertiser;
        private bool rewardedWatched;

        #region Initialize
        /// <summary>
        /// Initializing MoPub
        /// </summary>
        /// <param name="consent">user consent -> if true show personalized ads</param>
        /// <param name="platformSettings">contains all required settings for this publisher</param>
        public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, List<PlatformSettings> platformSettings)
        {
            debug = Advertisements.Instance.debug;
            if (initialized == false)
            {
                initialized = true;
                //get settings
#if UNITY_ANDROID
                PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.Android);
#endif
#if UNITY_IOS
            PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.iOS);
#endif
                //apply settings
                bannerAdUnit = settings.idBanner.id;
                interstitialAdUnit = settings.idInterstitial.id;
                rewardedVideoAdUnit = settings.idRewarded.id;
                this.consent = consent;
                this.ccpaConsent = ccpaConsent;

                //verify settings
                if (debug)
                {
                    Debug.Log(this + " Initialize");
                    ScreenWriter.Write(this + " Initialize");
                    Debug.Log(this + " Banner ID: " + bannerAdUnit);
                    ScreenWriter.Write(this + " Banner ID: " + bannerAdUnit);
                    Debug.Log(this + " Interstitial ID: " + interstitialAdUnit);
                    ScreenWriter.Write(this + " Interstitial ID: " + interstitialAdUnit);
                    Debug.Log(this + " Rewarded ID: " + rewardedVideoAdUnit);
                    ScreenWriter.Write(this + " Rewarded ID: " + rewardedVideoAdUnit);
                }

                MoPubManager.OnSdkInitializedEvent += SDKInitialized;
                string defaultID = null;
                if (string.IsNullOrEmpty(defaultID))
                {
                    defaultID = bannerAdUnit;
                }
                if (string.IsNullOrEmpty(defaultID))
                {
                    defaultID = interstitialAdUnit;
                }
                if (string.IsNullOrEmpty(defaultID))
                {
                    defaultID = rewardedVideoAdUnit;
                }

                if (!string.IsNullOrEmpty(defaultID))
                {
                    MoPub.InitializeSdk(defaultID);
                }
            }
        }

        /// <summary>
        /// Called after SDK was initialized
        /// </summary>
        /// <param name="defaultID">ID used to initialize SDK</param>
        private void SDKInitialized(string defaultID)
        {
            if (debug)
            {
                Debug.Log(this + " Initialized " + defaultID);
                ScreenWriter.Write(this + " Initialized " + defaultID);
            }

            UpdateConsent(consent, ccpaConsent);

            //prepare ad types
            if (!string.IsNullOrEmpty(bannerAdUnit))
            {
                MoPubManager.OnAdLoadedEvent += OnAdLoadedEvent;
                MoPubManager.OnAdFailedEvent += OnAdFailedEvent;

                MoPub.LoadBannerPluginsForAdUnits(new string[] { bannerAdUnit });
            }

            if (!string.IsNullOrEmpty(interstitialAdUnit))
            {
                MoPubManager.OnInterstitialLoadedEvent += InterstitialLoaded;
                MoPubManager.OnInterstitialFailedEvent += InterstitialFailed;
                MoPubManager.OnInterstitialDismissedEvent += InterstitialClosed;
                MoPub.LoadInterstitialPluginsForAdUnits(new string[] { interstitialAdUnit });
                LoadInterstitial();
            }

            if (!string.IsNullOrEmpty(rewardedVideoAdUnit))
            {
                MoPubManager.OnRewardedVideoLoadedEvent += RewardedVideoLoaded;
                MoPubManager.OnRewardedVideoFailedEvent += RewardedVideoFailed;
                MoPubManager.OnRewardedVideoFailedToPlayEvent += RewardedVideoFailed;
                MoPubManager.OnRewardedVideoClosedEvent += OnAdClosed;
                MoPubManager.OnRewardedVideoReceivedRewardEvent += RewardedVideoWatched;
                MoPub.LoadRewardedVideoPluginsForAdUnits(new string[] { rewardedVideoAdUnit });
                LoadRewardedVideo();
            }
        }


        /// <summary>
        /// Updates consent at runtime
        /// </summary>
        /// <param name="consent">the new consent</param>
        public void UpdateConsent(UserConsent consent, UserConsent ccpaConsent)
        {
            if (consent == UserConsent.Deny || ccpaConsent == UserConsent.Deny)
            {
                MoPub.PartnerApi.RevokeConsent();
            }
            else
            {
                MoPub.PartnerApi.GrantConsent();
            }

            if (debug)
            {
                Debug.Log(this + " Update consent to " + consent + " " + MoPub.CurrentConsentStatus);
                ScreenWriter.Write(this + " Update consent to " + consent + " " + MoPub.CurrentConsentStatus);
            }
        }
        #endregion

        #region Banners
        /// <summary>
        /// Show MoPub banner
        /// </summary>
        /// <param name="position"> can be TOP or BOTTOM</param>
        ///  /// <param name="bannerType"> can be Banner or SmartBanner</param>
        public void ShowBanner(BannerPosition position, BannerType bannerType, UnityAction<bool, BannerPosition, BannerType> DisplayResult)
        {
            bannerUsed = true;
            this.DisplayResult = DisplayResult;
            this.position = position;
            this.bannerType = bannerType;
            HideBanner();
            MoPub.AdPosition bannerPosition;
            if (position == BannerPosition.BOTTOM)
            {
                bannerPosition = MoPub.AdPosition.BottomCenter;
            }
            else
            {
                bannerPosition = MoPub.AdPosition.TopCenter;
            }
            MoPub.MaxAdSize bannerSize;
            if (bannerType == BannerType.Banner)
            {
                bannerSize = MoPub.MaxAdSize.Width300Height50;
            }
            else
            {
                bannerSize = MoPub.MaxAdSize.ScreenWidthHeight50;
            }

            MoPub.RequestBanner(bannerAdUnit, bannerPosition, bannerSize);
        }


        /// <summary>
        /// Event triggered when banner failed to load
        /// </summary>
        /// <param name="ID">loaded ID</param>
        /// <param name="reason"><failed reason/param>
        private void OnAdFailedEvent(string ID, string reason)
        {
            if (debug)
            {
                Debug.Log(this + " OnAdFailedEvent ID:" + ID + " Reason " + reason);
                ScreenWriter.Write(this + " OnAdFailedEvent ID:" + ID + " Reason " + reason);
            }

            if (DisplayResult != null)
            {
                DisplayResult(false, position, bannerType);
                DisplayResult = null;
            }
        }

        /// <summary>
        /// Event triggered when banner load is succesfull
        /// </summary>
        /// <param name="ID"></param>
        /// <param name="height"></param>
        private void OnAdLoadedEvent(string ID, float height)
        {
            if (debug)
            {
                Debug.Log(this + " OnAdLoadedEvent " + ID + " " + height);
                ScreenWriter.Write(this + " OnAdLoadedEvent " + ID + " " + height);
            }

            if (DisplayResult != null)
            {
                DisplayResult(true, position, bannerType);
                DisplayResult = null;
            }
        }

        /// <summary>
        /// Used for mediation purpose
        /// </summary>
        /// <returns>true if current banner failed to load</returns>
        public bool BannerAlreadyUsed()
        {
            return bannerUsed;
        }

        /// <summary>
        /// Hides MoPub banner
        /// </summary>
        public void HideBanner()
        {
            MoPub.DestroyBanner(bannerAdUnit);
        }

        /// <summary>
        /// Check if MoPub banner is available
        /// </summary>
        /// <returns>true if a banner is available</returns>
        public bool IsBannerAvailable()
        {
            return true;
        }

        /// <summary>
        /// Used for mediation purpose
        /// </summary>
        public void ResetBannerUsage()
        {
            bannerUsed = false;
        }
        #endregion

        #region Interstitial
        /// <summary>
        /// Check if MoPub interstitial is available
        /// </summary>
        /// <returns>true if an interstitial is available</returns>
        public bool IsInterstitialAvailable()
        {
            return MoPub.IsInterstitialReady(interstitialAdUnit);
        }


        /// <summary>
        /// Show MoPub interstitial
        /// </summary>
        /// <param name="InterstitialClosed">callback called when user closes interstitial</param>
        public void ShowInterstitial(UnityAction InterstitialClosed)
        {
            if (IsInterstitialAvailable())
            {
                OnInterstitialClosed = InterstitialClosed;
                MoPub.ShowInterstitialAd(interstitialAdUnit);
            }
        }

        /// <summary>
        /// Show MoPub interstitial
        /// </summary>
        /// <param name="InterstitialClosed">callback called when user closes interstitial</param>
        public void ShowInterstitial(UnityAction<string> InterstitialClosed)
        {
            if (IsInterstitialAvailable())
            {
                OnInterstitialClosedWithAdvertiser = InterstitialClosed;
                MoPub.ShowInterstitialAd(interstitialAdUnit);
            }
        }

        /// <summary>
        /// Event triggered when an interstitial is closed
        /// </summary>
        /// <param name="adUnitId"></param>
        private void InterstitialClosed(string adUnitId)
        {
            if (debug)
            {
                Debug.Log(this + " Reload Interstitial");
                ScreenWriter.Write(this + " Reload Interstitial");
            }

            //reload interstitial
            LoadInterstitial();

            //trigger complete event
            if (OnInterstitialClosed != null)
            {
                OnInterstitialClosed();
                OnInterstitialClosed = null;
            }
            if (OnInterstitialClosedWithAdvertiser != null)
            {
                OnInterstitialClosedWithAdvertiser(SupportedAdvertisers.MoPub.ToString());
                OnInterstitialClosedWithAdvertiser = null;
            }
        }

        /// <summary>
        /// Coroutine to reload an interstitial after a fail
        /// </summary>
        /// <param name="reloadTime">time to wait</param>
        /// <returns></returns>
        private IEnumerator ReloadInterstitial(float reloadTime)
        {
            yield return new WaitForSeconds(reloadTime);
            LoadInterstitial();
        }

        /// <summary>
        /// Loads MoPub interstitial
        /// </summary>
        private void LoadInterstitial()
        {
            if (debug)
            {
                Debug.Log(this + " Start Loading Interstitial");
                ScreenWriter.Write(this + " Start Loading Interstitial");
            }

            MoPub.RequestInterstitialAd(interstitialAdUnit);
        }

        /// <summary>
        /// Event triggered when an interstitial failed to load
        /// </summary>
        /// <param name="ID"></param>
        /// <param name="message"></param>
        private void InterstitialFailed(string ID, string message)
        {
            if (debug)
            {
                Debug.Log(this + " Interstitial Failed To Load " + message);
                ScreenWriter.Write(this + " Interstitial Failed To Load " + message);
            }

            //try again to load a rewarded video
            if (currentRetryInterstitial < maxRetryCount)
            {
                currentRetryInterstitial++;
                if (debug)
                {
                    Debug.Log(this + " RETRY " + currentRetryInterstitial);
                    ScreenWriter.Write(this + " RETRY " + currentRetryInterstitial);
                }
                StartCoroutine(ReloadInterstitial(reloadTime));
            }
        }

        /// <summary>
        /// Event triggered when interstitial is loaded 
        /// </summary>
        /// <param name="adUnitId"></param>
        private void InterstitialLoaded(string adUnitId)
        {
            if (debug)
            {
                Debug.Log(this + " Interstitial Loaded");
                ScreenWriter.Write(this + " Interstitial Loaded");
            }
            currentRetryInterstitial = 0;
        }
        #endregion

        #region RewardedVideo
        /// <summary>
        /// Check if MoPub rewarded video is available
        /// </summary>
        /// <returns>true if a rewarded video is available</returns>
        public bool IsRewardVideoAvailable()
        {
            return rewardedVideoAvailable;
        }

        /// <summary>
        /// Show MoPub rewarded video
        /// </summary>
        /// <param name="CompleteMethod">callback called when user closes the rewarded video -> if true video was not skipped</param>
        public void ShowRewardVideo(UnityAction<bool> CompleteMethod)
        {
            if (IsRewardVideoAvailable())
            {
                OnCompleteMethod = CompleteMethod;
                MoPub.ShowRewardedVideo(rewardedVideoAdUnit);
            }
        }

        /// <summary>
        /// Show MoPub rewarded video
        /// </summary>
        /// <param name="CompleteMethod">callback called when user closes the rewarded video -> if true video was not skipped</param>
        public void ShowRewardVideo(UnityAction<bool, string> CompleteMethod)
        {
            if (IsRewardVideoAvailable())
            {
                OnCompleteMethodWithAdvertiser = CompleteMethod;
                MoPub.ShowRewardedVideo(rewardedVideoAdUnit);
            }
        }

        /// <summary>
        /// Loads a MoPub rewarded video
        /// </summary>
        private void LoadRewardedVideo()
        {
            if (debug)
            {
                Debug.Log(this + "Start Loading Rewarded Video");
                ScreenWriter.Write(this + "Start Loading Rewarded Video");
            }

            MoPub.RequestRewardedVideo(rewardedVideoAdUnit);
        }

        /// <summary>
        /// Triggered when a rewarded video is fully watched
        /// </summary>
        /// <param name="ID"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        private void RewardedVideoWatched(string ID, string arg2, float arg3)
        {
            rewardedVideoAvailable = false;
            if (debug)
            {
                Debug.Log(this + " RewardedVideoWatched");
                ScreenWriter.Write(this + " RewardedVideoWatched");
            }
            rewardedWatched = true;
        }


        /// <summary>
        /// Triggered when a rewarded video is closed
        /// </summary>
        /// <param name="ID"></param>
        private void OnAdClosed(string ID)
        {
            rewardedVideoAvailable = false;
            if (debug)
            {
                Debug.Log(this + " OnAdClosed");
                ScreenWriter.Write(this + " OnAdClosed");
            }

            //reload
            LoadRewardedVideo();

            if (OnCompleteMethod != null)
            {
                OnCompleteMethod(rewardedWatched);
                OnCompleteMethod = null;
            }
            if (OnCompleteMethodWithAdvertiser != null)
            {
                OnCompleteMethodWithAdvertiser(rewardedWatched, SupportedAdvertisers.MoPub.ToString());
                OnCompleteMethodWithAdvertiser = null;
            }

            rewardedWatched = false;
        }


        /// <summary>
        /// Triggered when a rewarded video failed to load
        /// </summary>
        /// <param name="ID"></param>
        /// <param name="message"></param>
        private void RewardedVideoFailed(string ID, string message)
        {
            rewardedVideoAvailable = false;

            if (debug)
            {
                Debug.Log(this + " Rewarded Video Failed " + message);
                ScreenWriter.Write(this + " Rewarded Video Failed " + message);
            }

            //try again to load a rewarded video
            if (currentRetryRewardedVideo < maxRetryCount)
            {
                currentRetryRewardedVideo++;
                if (debug)
                {
                    Debug.Log("MoPub RETRY " + currentRetryRewardedVideo);
                    ScreenWriter.Write("MoPub RETRY " + currentRetryRewardedVideo);
                }
                StartCoroutine(ReloadRewardedVideo(reloadTime));
            }
        }


        /// <summary>
        /// Called to reload a video after a failed atempt
        /// </summary>
        /// <param name="reloadTime">time to wait</param>
        /// <returns></returns>
        private IEnumerator ReloadRewardedVideo(float reloadTime)
        {
            yield return new WaitForSeconds(reloadTime);
            LoadRewardedVideo();
        }


        /// <summary>
        /// Called when a rewarded video was successfully loaded 
        /// </summary>
        /// <param name="ID"></param>
        private void RewardedVideoLoaded(string ID)
        {
            rewardedVideoAvailable = true;
            if (debug)
            {
                Debug.Log(this + " Rewarded Video Loaded");
                ScreenWriter.Write(this + " Rewarded Video Loaded");
            }
            currentRetryRewardedVideo = 0;
        }
        #endregion

        private void OnApplicationFocus(bool focus)
        {
            if (focus == true)
            {
                if (IsInterstitialAvailable() == false)
                {
                    if (currentRetryInterstitial == maxRetryCount)
                    {
                        LoadInterstitial();
                    }
                }

                if (IsRewardVideoAvailable() == false)
                {
                    if (currentRetryRewardedVideo == maxRetryCount)
                    {
                        LoadRewardedVideo();
                    }
                }
            }
        }

#else
        public bool BannerAlreadyUsed()
        {
            return false;
        }

        public void HideBanner()
        {
            
        }

        public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, List<PlatformSettings> platformSettings)
        {
            
        }

        public bool IsBannerAvailable()
        {
            return false;
        }

        public bool IsInterstitialAvailable()
        {
            return false;
        }

        public bool IsRewardVideoAvailable()
        {
            return false;
        }

        public void ResetBannerUsage()
        {
           
        }

        public void ShowBanner(BannerPosition position, BannerType bannerType, UnityAction<bool, BannerPosition, BannerType> DisplayResult)
        {
            
        }

        public void ShowInterstitial(UnityAction InterstitialClosed)
        {
            
        }

        public void ShowInterstitial(UnityAction<string> InterstitialClosed)
        {
            
        }

        public void ShowRewardVideo(UnityAction<bool> CompleteMethod)
        {
           
        }

        public void ShowRewardVideo(UnityAction<bool, string> CompleteMethod)
        {
            
        }

        public void UpdateConsent(UserConsent consent, UserConsent ccpaConsent)
        {
            
        }
#endif

    }
}