com.amanotes.gdk 0.1.21 → 0.2.2

package/Runtime/AmaGDK.Ads.cs

@@ -1,221 +1,593 @@
 using System;
 using System.Collections;
-
+using System.Collections.Generic;
 using UnityEngine;
-
 using Amanotes.Core.Internal;
 using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.AmaGDK;
 
 namespace Amanotes.Core
 {
-    public interface IAds
+    public static class AdExtension
     {
-        bool IsAdReady(AdType Type);
-
-        #region Interstitial   
-        event Action InterstitialShowSucceededCallback;
-        event Action InterstitialShowFailedCallback;
-        event Action InterstitialClickedCallback;
-        void RequestInterstitial();
-        void ShowInterstitial();
-        void ShowInterstitial(string placementName);
-        #endregion FullAds
-
-        #region VideoAds     
-        event Action RewardedVideoShowFailedCallback;
-        event Action RewardedVideoClosedCallback;
-        event Action RewardedCallback;
-        event Action RewardedVideoClickCallback;
-        void RequestRewardedVideo();
-        void ShowRewardedVideo();
-        void ShowRewardedVideo(string placementName);
-        #endregion VideoAds
-
-        #region Banner
-        event Action BannerAdsClickCallback;
-        event Action BannerShowCallback;        
-        void RequestBanner(BannerPosition position = BannerPosition.TOP);
-        void RequestBanner(BannerPosition position, string placementName);
-        void ShowBanner();
-        void HideBanner();
-        #endregion Banner
+        public static IAdCallback OnAdOpened(this IAdCallback ad, Action callback)
+        {
+            if (ad == null)
+                return null;
+            Ads.context.onOpened -= callback;
+            Ads.context.onOpened += callback;
+            return ad;
+        }
+
+        public static IAdCallback OnRewardReceived(this IAdCallback ad, Action callback)
+        {
+            if (ad == null)
+                return null;
+            Ads.context.onRewardReceived -= callback;
+            Ads.context.onRewardReceived += callback;
+            return ad;
+        }
+
+        public static IAdCallback OnAdClicked(this IAdCallback ad, Action callback)
+        {
+            if (ad == null)
+                return null;
+            Ads.context.onClicked -= callback;
+            Ads.context.onClicked += callback;
+            return ad;
+        }
+
+        public static IAdCallback OnAdShowFailed(this IAdCallback ad, Action callback)
+        {
+            if (ad == null)
+                return null;
+            Ads.context.onShowFailed -= callback;
+            Ads.context.onShowFailed += callback;
+            return ad;
+        }
+
+        public static IAdCallback OnAdShowSuccess(this IAdCallback ad, Action callback)
+        {
+            if (ad == null)
+                return null;
+            Ads.context.onShowSuccess -= callback;
+            Ads.context.onShowSuccess += callback;
+            return ad;
+        }
+
+        public static IAdCallback OnAdClosed(this IAdCallback ad, Action callback)
+        {
+            if (ad == null)
+                return null;
+            Ads.context.onClosed -= callback;
+            Ads.context.onClosed += callback;
+            return ad;
+        }
+
     }
 
-    public enum BannerPosition
+    public partial class AmaGDK // Ads module
     {
-        TOP = 1,
-        BOTTOM = 2
-    };
+        [Serializable]
+        internal class AdStat
+        {
+            internal int lastSuccessTime;
+            internal int success;
+            internal int failed;
 
-    public enum AdType : byte
-    {
-        Interstitial,
-        Reward,
-        Banner
-    };
+            public int successTotal;
+            public int failedTotal;
+        }
 
-    public partial class AmaGDK // IAds module
-    {
-        public static class Ads
+        [Serializable]
+        internal class AdsData : IJsonFile
         {
-            internal static IAds adsModule;
-            public static Action<string> OnInterstitalFailCallback;
-            public static Action<string> OnRewardedVideoFailCallback;
+            public AdStat interstitial = new AdStat();
+            public AdStat reward = new AdStat();
 
-            public static void Init()
-            {                                
-                adsModule =Adapter.GetSingleAdapter<IAds>();
+            internal int GetLastShowInSeconds(AdType adType)
+            {
+                return (int)(Time.realtimeSinceStartup - (adType == AdType.Interstitial ? interstitial.lastSuccessTime : reward.lastSuccessTime));
             }
 
-            public static void RequestBanner(BannerPosition position)
+            internal void Save()
             {
-                if (adsModule == null)
-                {
-                    LogWarning("Ads module is not initialized");
-                    return;
-                }
-                adsModule.RequestBanner(position);
+                this.SaveJsonToFile();
             }
+        }
 
-            public static void ShowBanner()
+        [Serializable]
+        public class AdAdapterConfig
+        {
+            public int adLoadTimeoutInSecs = 60;
+            public int adShowTimeoutInSecs = 5;
+            public BannerPosition bannerPosition = BannerPosition.BOTTOM;
+
+            public bool checkInternet = true;
+            public bool autoLogEvent = true;
+
+            public bool enableInterstitial = true;
+            public bool enableRewarded = true;
+            public bool enableBanner = true;
+            public bool autoMute = true;
+        }
+
+        public partial class Ads
+        {
+            public static ShowAdContext context;
+            public static bool allowAdRequest = true;
+
+            internal static AdAdapterConfig _adConfig;
+            internal static IAdAdapter _adapter;
+            public static AdListener Events = new AdListener();
+            internal static float _savedVolume = -1;
+            internal static AdsData localData = new AdsData().LoadJsonFromFile();
+        }
+
+        public partial class Ads // Public
+        {
+            internal static void Init()
             {
-                adsModule.ShowBanner();
+                _adapter = Adapter.GetSingleAdapter<IAdAdapter>();
+                _adConfig = ((AdapterContext)_adapter).GetAdapterConfig<AdAdapterConfig>();
+                _adapter.interstitial.StartLoadAd();
+                _adapter.rewardVideo.StartLoadAd();
             }
 
-            public static void HideBanner()
+            public static bool HasInterstitial => _adapter.interstitial.hasAd;
+            public static bool HasRewardedVideo => _adapter.rewardVideo.hasAd;
+
+            public static IAdCallback ShowInterstitial(string placementName = null, Dictionary<string, object> userData = null)
             {
-                if (!adsModule.IsAdReady(AdType.Banner))
+                if (context != null)
                 {
-                    LogWarning("Banner is not ready");
-                    return;
+                    LogWarning("Context != null, might some ad be showing???");
+                    context = null;
                 }
 
-                adsModule.HideBanner();
+                context = new ShowAdContext(AdType.Interstitial, placementName, userData);
+                _adapter.interstitial.StartShowAd();
+                return context;
             }
 
-            public static void RequestInterstitial()
+            public static IAdCallback ShowRewardedVideo(string placementName = null, Dictionary<string, object> userData = null)
             {
-                if (adsModule == null)
+                if (context != null)
                 {
-                    LogWarning("Ads module is not initialized");
-                    return;
+                    LogWarning("Context != null, might some ad be showing???");
+                    context = null;
                 }
-                adsModule.RequestInterstitial();
+
+                context = new ShowAdContext(AdType.VideoReward, placementName, userData);
+                _adapter.rewardVideo.StartShowAd();
+                return context;
             }
 
-            public static void ShowInterstitial()
+            private static bool _showingBanner = false;
+            public static void ShowBanner()
             {
-                if (!adsModule.IsAdReady(AdType.Interstitial))
-                {
-                    LogWarning("Interstitial is not ready");
-                    AmaGDK._instance.StartCoroutine(IWaitShowInterstitial());
-                    return;
-                }
-                adsModule.ShowInterstitial();
+                if (_showingBanner) return;
+                _showingBanner = true;
+                _adapter.ShowBanner(_adConfig.bannerPosition);
             }
 
-            public static void RequestRewardedVideo()
+            public static void HideBanner()
             {
-                if (adsModule == null)
-                {
-                    LogWarning("Ads module is not initialized");
-                    return;
-                }
-                adsModule.RequestRewardedVideo();
+                if (!_showingBanner) return;
+                _showingBanner = false;
+                _adapter.HideBanner();
             }
 
-            public static void ShowRewardedVideo()
+            public static void StopWaitForAd()
             {
-                if (!adsModule.IsAdReady(AdType.Reward))
-                {
-                    LogWarning("Reward is not ready");
-                    AmaGDK._instance.StartCoroutine(IWaitShowRewardedVideo());
+                if (context == null)
                     return;
-                }
-                adsModule.ShowRewardedVideo();
+
+                if (context.adType == AdType.Interstitial)
+                    _adapter.interstitial.StopShowAd();
+                else
+                    _adapter.rewardVideo.StopShowAd();
+
+                context = null;
+            }
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    public interface IAdCallback { }
+
+    public interface IAdAdapter
+    {
+        AdLogic interstitial { get; }
+        AdLogic rewardVideo { get; }
+
+        void ShowBanner(BannerPosition position);
+        void HideBanner();
+    }
+
+    public enum LoadAdsState
+    {
+        None,
+        Requesting,
+        Ready
+    }
+
+    public enum ShowAdsState
+    {
+        None,
+        ShowCalled,
+        WaitForAd,
+        Showing,
+        ShowFail,
+        ShowSuccess
+    }
+
+    [Flags]
+    public enum AdCallback
+    {
+        None,
+        Open,
+        Reward,
+        Click,
+        Cancel,
+        Close,
+        Success,
+        Fail
+    }
+
+    public enum BannerPosition
+    {
+        TOP = 1,
+        BOTTOM = 2
+    }
+
+    public enum AdType
+    {
+        Interstitial,
+        VideoReward,
+        Banner
+    }
+
+    public class ShowAdContext : IAdCallback
+    {
+        public readonly AdType adType;
+        public readonly string placementName;
+        public readonly Dictionary<string, object> userData;
+        public AdCallback adCallback;
+
+        internal Action onOpened;
+        internal Action onRewardReceived;
+        internal Action onClicked;
+        internal Action onShowSuccess;
+        internal Action onShowFailed;
+        internal Action onClosed;
+
+        // Stats
+        public float showCallAt;
+        public float showFinishAt;
+
+        public ShowAdContext(AdType adType, string placementName, Dictionary<string, object> userData)
+        {
+            this.adType = adType;
+            this.userData = userData;
+            this.placementName = placementName;
+            adCallback = AdCallback.None;
+            showCallAt = Time.time;
+            showFinishAt = 0;
+        }
+
+        public bool hasError => (adCallback & (AdCallback.Fail | AdCallback.Cancel)) != 0;
+        public bool hasCompleted => (adCallback & (AdCallback.Close | AdCallback.Reward | AdCallback.Cancel)) != 0;
+        public bool hasReward => (adCallback & AdCallback.Reward) != 0;
+        public bool hasCancel => (adCallback & AdCallback.Cancel) != 0;
+        public bool hasClicked => (adCallback & AdCallback.Click) != 0;
+    }
+
+    public abstract class AdLogic
+    {
+        private static readonly WaitForSeconds wait1Sec = new WaitForSeconds(1f);
+
+        internal LoadAdsState _loadState = LoadAdsState.None;
+        internal bool hasAd => _loadState == LoadAdsState.Ready;
+
+        internal Coroutine _loadRoutine;
+
+        public void StartLoadAd()
+        {
+            if (_loadState != LoadAdsState.None)
+            {
+                LogWarning("StartLoadAd() --> Invalid state: " + _loadState);
+                return;
             }
 
-            private static IEnumerator IWaitShowRewardedVideo()
+            _loadRoutine = _instance.StartCoroutine(LoadAdRoutine());
+        }
+
+        public void StopLoadAd()
+        {
+            if (_loadState == LoadAdsState.Requesting)
             {
-                LogWarning("Wait Show Rewarded Video");
-                if (adsModule == null)
-                {
-                    OnRewardedVideoFailCallback?.Invoke("Not found ads module");
-                    OnRewardedVideoFailCallback = null;
-                    yield break;
-                }
+                _loadState = LoadAdsState.None;
+            }
+
+            if (_loadRoutine == null) return;
 
-                var startTime = Time.time;
-                float timeout = 5;
-                string error = null;
-                while (!adsModule.IsAdReady(AdType.Reward))
+            _instance.StopCoroutine(_loadRoutine);
+            _loadRoutine = null;
+        }
+
+        IEnumerator LoadAdRoutine()
+        {
+            if (isAdReady)
+            {
+                _loadState = LoadAdsState.Ready;
+                yield break;
+            }
+
+            while (true)
+            {
+                yield return wait1Sec;
+
+                if (!Ads.allowAdRequest) continue;
+                if (Ads._adConfig.checkInternet && !hasInternet) continue;
+
+                _loadState = LoadAdsState.Requesting;
+                _isRequesting = true;
+                RequestAd();
+
+                var timeout = Ads._adConfig.adLoadTimeoutInSecs;
+                var counter = 0;
+
+                while (counter < timeout || timeout == 0)
                 {
-                    if (Application.internetReachability == NetworkReachability.NotReachable)
-                    {
-                        error = Application.internetReachability.ToString();
-                        break;
-                    }
-
-                    if ((Time.time - startTime) > timeout)
-                    {
-                        error = "Timeout";
-                        break;
-                    }
-
-                    yield return null;
+                    yield return wait1Sec;
+                    counter++;
+                    if (_isRequesting == false) break;
                 }
 
-                if (adsModule.IsAdReady(AdType.Reward))
+                if (counter > timeout && timeout > 0) // timeout
                 {
-                    adsModule.ShowRewardedVideo();
+                    continue;
                 }
-                else
+
+                // request should be completed here!
+                if (!isAdReady)
                 {
-                    OnRewardedVideoFailCallback?.Invoke(error);
-                    OnRewardedVideoFailCallback = null;
+                    LogWarning("Request complete but failed!");
+                    continue;
                 }
+
+                _loadState = LoadAdsState.Ready;
+                yield break;
             }
+        }
+
+        bool hasInternet => Application.internetReachability != NetworkReachability.NotReachable;
+
+        // Override by actual Ad instance
+        protected abstract AdType adType { get; }
+        protected abstract bool isAdReady { get; }
+        protected abstract void RequestAd();
+        protected abstract void ShowAd();
 
-            private static IEnumerator IWaitShowInterstitial()
+        // Show Ad logic
+        internal ShowAdsState _showState = ShowAdsState.None;
+        private Coroutine _showAdRoutine;
+        private bool _isRequesting;
+        internal bool isInterstitial => Ads.context.adType == AdType.Interstitial;
+
+        public void StartShowAd()
+        {
+            if (_showState != ShowAdsState.None)
             {
-                LogWarning("Wait Show Interstitial");
-                if (adsModule == null)
+                LogWarning("StartShowAd() --> Invalid _showState: " + _showState);
+            }
+
+            _showState = ShowAdsState.ShowCalled;
+            if (_showAdRoutine != null) _instance.StopCoroutine(_showAdRoutine);
+            _showAdRoutine = _instance.StartCoroutine(ShowAdRoutine());
+        }
+
+        public void StopShowAd()
+        {
+            _showState = ShowAdsState.None;
+            RestoreVolume();
+            if (_showAdRoutine == null) return;
+            _instance.StopCoroutine(_showAdRoutine);
+            _showAdRoutine = null;
+        }
+
+        IEnumerator ShowAdRoutine()
+        {
+            // Wait for Ad
+            if (!isAdReady)
+            {
+                if (_loadState == LoadAdsState.Ready)
                 {
-                    OnInterstitalFailCallback?.Invoke("Not found ads module");
-                    OnInterstitalFailCallback = null;
-                    yield break;
+                    LogWarning("Inconsistent state report: isAdReady == false while _loadState == Ready");
+                    _loadState = LoadAdsState.None;
                 }
 
-                var startTime = Time.time;
-                float timeout = 5;
-                string error = null;
-                while (!adsModule.IsAdReady(AdType.Interstitial))
+                if (Ads._adConfig.checkInternet && !hasInternet)
                 {
-                    if (Application.internetReachability == NetworkReachability.NotReachable)
-                    {
-                        error = Application.internetReachability.ToString();
-                        break;
-                    }
-
-                    if ((Time.time - startTime) > timeout)
-                    {
-                        error = "Timeout";
-                        break;
-                    }
-
-                    yield return null;
+                    _showState = ShowAdsState.ShowFail;
+                    yield break;
                 }
 
-                if (adsModule.IsAdReady(AdType.Interstitial))
+                if (_loadState != LoadAdsState.Requesting) StartLoadAd();
+                _showState = ShowAdsState.WaitForAd;
+
+                var timeout = Ads._adConfig.adShowTimeoutInSecs;
+                var counter = 0;
+
+                while (counter < timeout || timeout == 0)
                 {
-                    adsModule.ShowInterstitial();
+                    yield return wait1Sec;
+                    counter++;
+                    if (_loadState == LoadAdsState.Ready) break;
                 }
-                else
+
+                if (!isAdReady)
                 {
-                    OnInterstitalFailCallback?.Invoke(error);
-                    OnInterstitalFailCallback = null;
+                    _showState = ShowAdsState.ShowFail;
+                    yield break;
                 }
             }
+
+            // Ad should be ready here!
+            ShowAd();
+            if (Ads._adConfig.autoMute && AudioListener.volume > 0 && Ads._savedVolume == -1)
+            {
+                Ads._savedVolume = AudioListener.volume;
+                AudioListener.volume = 0;
+            }
+
+            var context = Ads.context;
+            while (!context.hasCompleted)
+            {
+                yield return wait1Sec;
+            }
+
+            if (adType == AdType.Interstitial)
+            {
+                _showState = context.hasError ? ShowAdsState.ShowFail : ShowAdsState.ShowSuccess;
+                ShowCompleted(_showState == ShowAdsState.ShowSuccess);
+                yield break;
+            }
+
+            // Should be rewardedVideo
+            if (!context.hasReward && !context.hasCancel) // no reward & no cancel: wait for the delayed reward callback
+            {
+                yield return wait1Sec;
+            }
+
+            _showState = context.hasError ? ShowAdsState.ShowFail : ShowAdsState.ShowSuccess;
+            ShowCompleted(_showState == ShowAdsState.ShowSuccess);
+        }
+
+        private void ShowCompleted(bool isSuccess)
+        {
+            bool isInterstitial = adType == AdType.Interstitial;
+            var adapter = Ads._adapter;
+            if (isInterstitial)
+                adapter.interstitial.StartLoadAd();
+            else
+                adapter.rewardVideo.StartLoadAd();
+
+            var localData = Ads.localData;
+            var stat = isInterstitial ? localData.interstitial : localData.reward;
+
+            if (isSuccess)
+            {
+                stat.success++;
+                stat.successTotal++;
+                stat.lastSuccessTime = (int)Time.realtimeSinceStartup;
+            }
+            else
+            {
+                stat.failed++;
+                stat.failedTotal++;
+            }
+
+            localData.Save();
+
+            RestoreVolume();
+        }
+
+        private void RestoreVolume()
+        {
+            if (!Ads._adConfig.autoMute || Ads._savedVolume <= 0)
+                return;
+            AudioListener.volume = Ads._savedVolume;
+            Ads._savedVolume = -1;
+        }
+
+        // Default implementation
+        protected void OnAdClosed()
+        {
+            Ads.context.adCallback |= AdCallback.Close;
+            Ads.context.onClosed?.Invoke();
+            if (isInterstitial)
+                Ads.Events.OnInterstitialClosed?.Invoke();
+            else
+                Ads.Events.OnRewardedClosed?.Invoke();
+        }
+
+        protected void OnAdClicked()
+        {
+            Ads.context.adCallback |= AdCallback.Click;
+            Ads.context.onClicked?.Invoke();
+            if (isInterstitial)
+                Ads.Events.OnInterstitialClicked?.Invoke();
+            else
+                Ads.Events.OnRewardedClicked?.Invoke();
+        }
+
+        protected void OnAdShowFailed()
+        {
+            Ads.context.adCallback |= AdCallback.Fail;
+            Ads.context.onShowFailed?.Invoke();
+            if (isInterstitial)
+                Ads.Events.OnInterstitialShowFailed?.Invoke();
+            else
+                Ads.Events.OnRewardedShowFailed?.Invoke();
+
+            Ads.context = null;
+        }
+
+        protected void OnAdShowSucceeded()
+        {
+            Ads.context.adCallback |= AdCallback.Success;
+            Ads.context.onShowSuccess?.Invoke();
+            if (isInterstitial)
+                Ads.Events.OnInterstitialShowSucceeded?.Invoke();
+
+            Ads.context = null;
+        }
+
+        protected void OnAdOpen()
+        {
+            Ads.context.adCallback |= AdCallback.Open;
+            Ads.context.onOpened?.Invoke();
+            if (isInterstitial)
+                Ads.Events.OnInterstitialOpened?.Invoke();
+            else
+                Ads.Events.OnRewardedOpened?.Invoke();
+        }
+
+        protected void OnAdReward()
+        {
+            Ads.context.adCallback |= AdCallback.Reward;
+            Ads.context.onRewardReceived?.Invoke();
+            if (!isInterstitial)
+                Ads.Events.OnRewardedReceived?.Invoke();
+        }
+
+        protected void OnAdReady()
+        {
+            if (!_isRequesting)
+            {
+                LogWarning("Something wrong? OnAdReady called when no ad is loading!");
+            }
+
+            _isRequesting = false;
         }
     }
-}
+
+    public class AdListener
+    {
+        public Action OnRewardedOpened;
+        public Action OnRewardedReceived;
+        public Action OnRewardedClicked;
+        public Action OnRewardedShowFailed;
+        public Action OnRewardedClosed;
+
+        public Action OnInterstitialOpened;
+        public Action OnInterstitialShowSucceeded;
+        public Action OnInterstitialShowFailed;
+        public Action OnInterstitialClicked;
+        public Action OnInterstitialClosed;
+    }
+}