com.amanotes.gdk 0.2.66 → 0.2.67

package/Runtime/Ad/AdLogic.cs

@@ -0,0 +1,530 @@
+using System.Collections;
+using UnityEngine;
+using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.AmaGDK;
+
+namespace Amanotes.Core.Internal
+{
+    public abstract class AdLogic
+    {
+        protected AdModuleConfig adConfig => Config.ad;
+        protected AdShowContext context => Ads.context;
+        
+        internal LoadAdsState _loadState = LoadAdsState.None;
+        internal bool hasAd
+        {
+            get
+            {
+                if (_loadState == LoadAdsState.Ready && !isAdReady)
+                {
+                    LogWarning("[Ad] Inconsistent Ready state (might caused by poor internet condition)");
+                    _loadState = LoadAdsState.None;
+                    StartLoadAd();
+                }
+
+                return _loadState == LoadAdsState.Ready;
+            }
+        }
+
+        internal Coroutine _loadRoutine;
+
+        public void StartLoadAd()
+        {
+            if (_loadState != LoadAdsState.None)
+            {
+                LogWarning("[Ad] StartLoadAd() --> Invalid state: " + _loadState);
+                return;
+            }
+
+            Log("[Ad] StartLoadAd");
+            _loadRoutine = _instance.StartCoroutine(LoadAdRoutine());
+        }
+
+        public void StopLoadAd()
+        {
+            Log("[Ad] StopLoadAd");
+            if (_loadState == LoadAdsState.Requesting)
+            {
+                _loadState = LoadAdsState.None;
+            }
+
+            if (_loadRoutine == null) return;
+            _instance.StopCoroutine(_loadRoutine);
+            _loadRoutine = null;
+        }
+
+        IEnumerator LoadAdRoutine()
+        {
+            if (isAdReady)
+            {
+                Log("[Ad] LoadAdRoutine skipped because isAdReady = true!");
+                _loadState = LoadAdsState.Ready;
+                yield break;
+            }
+
+            var wait1Sec = new WaitForSecondsRealtime(1f);
+            Log("[Ad] LoadAdRoutine start(): isAdReady = " + isAdReady);
+            while (true)
+            {
+                yield return wait1Sec;
+
+                if (!Ads.allowAdRequest)
+                {
+                    Log("[Ad] LoadAdRoutine: allowAdRequest = false");
+                    continue;
+                }
+
+                if (!HasLocalNetworkConnection)
+                {
+                    Log("[Ad] LoadAdRoutine: hasInternet = " + HasLocalNetworkConnection);
+                    continue;
+                }
+
+                _loadState = LoadAdsState.Requesting;
+                _isRequesting = true;
+                Log("[Ad] LoadAdRoutine: RequestAd()");
+                RequestAd();
+                dispatcher.Dispatch(
+                    _isInterstitial ? AmaGDK.Event.INTER_REQUEST : AmaGDK.Event.REWARD_REQUEST
+                );
+
+                int timeout = Config.ad.adLoadTimeoutInSecs;
+                var counter = 0;
+
+                while (counter < timeout || timeout == -1)
+                {
+                    yield return wait1Sec;
+                    counter++;
+                    if (_isRequesting == false) break;
+                }
+
+                if (counter > timeout && timeout > 0) // timeout
+                {
+                    Log("[Ad] LoadAdRoutine: RequestAd not responding (timeout) " + timeout + " secs");
+                    continue;
+                }
+                
+                // request should be completed here!
+                if (!isAdReady)
+                {
+                    LogWarning($"[Ad] Request complete but failed! (load duration = {counter} secs)");
+                    continue;
+                }
+
+                _loadState = LoadAdsState.Ready;
+                Log($"[Ad] LoadAdRoutine: Ad is ready! (load duration = {counter} secs)");
+                yield break;
+            }
+        }
+
+        bool HasLocalNetworkConnection => 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();
+
+        // Show Ad logic
+        internal ShowAdsState _showState = ShowAdsState.None;
+        private Coroutine _showAdRoutine;
+        protected bool _isRequesting;
+        protected bool _isInterstitial => adType == AdType.Interstitial;
+        
+        public void StartShowAd()
+        {
+            unityCallbacks.OnApplicationFocus -= OnApplicationFocus;
+            unityCallbacks.OnApplicationFocus += OnApplicationFocus;
+            
+            if (_showState != ShowAdsState.None)
+            {
+                LogWarning("[Ad] StartShowAd() --> Invalid _showState: " + _showState);
+            }
+
+            Log($"[Ad] {adType} StartShowAd");
+            _showState = ShowAdsState.ShowCalled;
+
+            AdStat stat = Ads.localData.GetStat(adType);
+            stat.callCount++;
+            stat.prevCallTime = stat.currentCallTime;
+            stat.currentCallTime = Time.realtimeSinceStartup;
+            
+            dispatcher.Dispatch(
+                _isInterstitial ? AmaGDK.Event.INTER_SHOW_CALLED : AmaGDK.Event.REWARD_VIDEO_SHOW_CALLED
+            );
+
+            if (_showAdRoutine != null) _instance.StopCoroutine(_showAdRoutine);
+            _showAdRoutine = _instance.StartCoroutine(ShowAdRoutine());
+        }
+
+        void OnApplicationFocus(bool isFocus)
+        {
+            if (!isFocus) return;
+            
+            unityCallbacks.OnApplicationFocus -= OnApplicationFocus;
+            if (context == null) return;
+            
+            Log($"OnApplicationFocus Before: {context.hasClosed}");
+            context.adCallback |= AdCallback.Close;
+            Log($"OnApplicationFocus After: {context.hasClosed}");
+        }
+
+        public void StopShowAd()
+        {
+            Log($"[Ad] {adType} StopShowAd");
+            _showState = ShowAdsState.None;
+            if (_loadState == LoadAdsState.Ready && !isAdReady)
+            {
+                _loadState = LoadAdsState.None;
+                StartLoadAd();
+            }
+
+            TriggerOnAfterAdShow();
+            if (_showAdRoutine == null) return;
+            _instance.StopCoroutine(_showAdRoutine);
+            _showAdRoutine = null;
+
+            if (Ads.context.adType == AdType.Interstitial)
+            {
+                ShowAdRoutineCompleted(!Ads.context.hasFailedOrCancelled);
+            } else
+            {
+                ShowAdRoutineCompleted(Ads.context.hasReward);
+            }
+        }
+
+        IEnumerator ShowAdRoutine()
+        {
+            // Wait to end frame so that all AdCallbacks finish registering
+            yield return new WaitForEndOfFrame();
+
+            // Wait for Ad
+            if (!isAdReady)
+            {
+                if (_loadState == LoadAdsState.Ready)
+                {
+                    LogWarning("[Ad] Inconsistent state report: isAdReady == false while _loadState == Ready");
+                    _loadState = LoadAdsState.None;
+                }
+
+                if (!HasLocalNetworkConnection)
+                {
+                    _showState = ShowAdsState.ShowFail;
+                    OnAdShowReadyStatus(false, AdShowReadyStatus.Wifi3GDisabled);
+                    ShowAdRoutineCompleted(false);
+                    yield break;
+                }
+
+                int timeout = Config.ad.adShowTimeoutInSecs;
+                if (timeout == 0) // do not wait for Ad
+                {
+                    _showState = ShowAdsState.ShowFail;
+                    OnAdShowReadyStatus(false, AdShowReadyStatus.TimeOut);
+                    ShowAdRoutineCompleted(false);
+                    yield break;
+                }
+
+                _showState = ShowAdsState.WaitForAd;
+                OnAdShowReadyStatus(false, AdShowReadyStatus.WaitForAd);
+
+                if (_loadState != LoadAdsState.Requesting) StartLoadAd();
+                var counter = 0;
+                bool? hasInternet = null;
+                if (adConfig.checkInternet) _instance.StartCoroutine(WebUtils.CheckInternet(result => hasInternet = result));
+
+                var wait1Sec = new WaitForSecondsRealtime(1f);
+                while (counter < timeout || timeout == -1)
+                {
+                    yield return wait1Sec;
+                    counter++;
+
+                    // finish checking internet & result is false
+                    if (adConfig.checkInternet && hasInternet == false)
+                    {
+                        Log("[Ad] Stop WaitForAd : No internet!");
+                        _showState = ShowAdsState.ShowFail;
+                        OnAdShowReadyStatus(false, AdShowReadyStatus.NoInternet);
+                        ShowAdRoutineCompleted(false);
+                        yield break;
+                    }
+
+                    if (_loadState != LoadAdsState.Ready) continue;
+                    Log("[Ad] WaitForAd success after " + counter + " | timeout = " + timeout + " secs");
+                    break;
+                }
+
+                if (!isAdReady)
+                {
+                    Log("[Ad] WaitForAd failed (timeout) " + counter + " | timeout = " + timeout + " secs");
+                    OnAdShowReadyStatus(false, AdShowReadyStatus.TimeOut);
+                    ShowAdRoutineCompleted(false);
+                    yield break;
+                }
+            }
+
+            _showState = ShowAdsState.Showing;
+            OnAdShowReadyStatus(true, AdShowReadyStatus.Ready);
+            TriggerBeforeAdShow();
+            ShowAd();
+            
+            while (!context.potentiallyCompleted)
+            {
+                yield return null; // callback as quickly as possible
+            }
+
+            if (adType == AdType.Interstitial)
+            {
+                ShowAdRoutineCompleted(!context.hasFailedOrCancelled);
+                yield break;
+            }
+
+            if (context.hasFailedOrCancelled)
+            {
+                Log($"[Ad] {adType} Waiting for [close]");
+                yield return null;
+                ShowAdRoutineCompleted(false);
+                yield break;
+            }
+
+            if (context.hasClosed)
+            {
+                // wait 1 frame in case hasReward callback after onClose
+                if (!context.hasReward) yield return null;
+                ShowAdRoutineCompleted(context.hasReward);
+                yield break;
+            }
+
+            var wait4CloseCounter = 0;
+            while (!context.hasClosed)
+            {
+                wait4CloseCounter++;
+                Log($"[Ad] {adType} Waiting for [close]:  {wait4CloseCounter}");
+                yield return null;
+            }
+            
+            ShowAdRoutineCompleted(true);
+        }
+
+        private void ShowAdRoutineCompleted(bool isSuccess)
+        {
+            if (_loadState == LoadAdsState.Ready)
+            {
+                _loadState = isAdReady ? LoadAdsState.Ready : LoadAdsState.None;
+                if (_loadState == LoadAdsState.None) StartLoadAd();
+            }
+
+            _showState = isSuccess ? ShowAdsState.ShowSuccess : ShowAdsState.ShowFail;
+
+            // Extra callback
+            Ads.context.showFinishAt = Time.realtimeSinceStartup;
+            Ads.context.onAdResult?.Invoke(isSuccess);
+
+            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();
+            TriggerOnAfterAdShow();
+
+            Log($"[Ad] {adType} ShowAdRoutineCompleted: {isSuccess}\n{JsonUtility.ToJson(Ads.context)}");
+            Ads.context = null;
+            _showState = ShowAdsState.None;
+        }
+
+        private void TriggerBeforeAdShow()
+        {
+            bool willSaveVolume = Config.ad.autoMute
+                && AudioListener.volume > 0
+                && Ads._savedVolume < 0;
+
+            bool willSaveTimeScale = Config.ad.autoTimeScale
+                && Time.timeScale > 0
+                && Ads._savedTimeScale < 0;
+
+            if (willSaveVolume)
+            {
+                Ads._savedVolume = AudioListener.volume;
+                AudioListener.volume = 0;
+            }
+
+            if (willSaveTimeScale)
+            {
+                Ads._savedTimeScale = Time.timeScale;
+                Time.timeScale = 0;
+            }
+
+            dispatcher.Dispatch(_isInterstitial ? AmaGDK.Event.INTER_SHOW_BEGIN : AmaGDK.Event.REWARD_VIDEO_SHOW_BEGIN);
+            Ads.context.onBeforeAdOpen?.Invoke();
+        }
+
+        private void TriggerOnAfterAdShow()
+        {
+            bool willRestoreVolume = Config.ad.autoMute
+                && AudioListener.volume == 0
+                && Ads._savedVolume > 0;
+
+            bool willRestoreTimeScale = Config.ad.autoTimeScale
+                && Time.timeScale == 0
+                && Ads._savedTimeScale > 0;
+
+            if (willRestoreVolume)
+            {
+                AudioListener.volume = Ads._savedVolume;
+                Ads._savedVolume = -1;
+            }
+
+            if (willRestoreTimeScale)
+            {
+                Time.timeScale = Ads._savedTimeScale;
+                Ads._savedTimeScale = -1;
+            }
+            
+            bool isSuccess = _showState == ShowAdsState.ShowSuccess;
+            dispatcher.Dispatch(_isInterstitial ? AmaGDK.Event.INTER_SHOW_END : AmaGDK.Event.REWARD_VIDEO_SHOW_END, isSuccess);
+        }
+
+        // Default implementation
+        protected void OnAdClosed()
+        {
+            Log($"[Ad] {adType} OnAdClosed");
+
+            if (Ads.context != null)
+            {
+                Ads.context.adCallback |= AdCallback.Close;
+                Ads.context.onClosed?.Invoke();
+            } else
+            {
+                LogWarning("[Ad] OnAdClosed() Something wrong - No AdContext");
+            }
+        }
+
+        protected void OnAdClicked()
+        {
+            Log($"[Ad] {adType} OnAdClicked");
+
+            if (Ads.context != null)
+            {
+                Ads.context.adCallback |= AdCallback.Click;
+                Ads.context.onClicked?.Invoke();
+            } else
+            {
+                LogWarning("[Ad] OnAdClicked() Something wrong - No AdContext");
+            }
+        }
+
+        protected void OnAdShowFailed()
+        {
+            Log($"[Ad] {adType} OnAdShowFailed");
+            
+            // 509		Show Fail: No ads to show
+            // 520		Show Fail: No internet connection; ShouldTrackNetworkState is enabled
+            // 524		Show Fail: Placement %@ has reached its limit as defined per pace
+            // 526		Show Fail: Ad unit has reached its daily cap per session
+            // 1022		Show Fail: Cannot show an RV while another RV is showing
+            // 1023		Show Fail: Show RV called when there are no available ads to show
+            // 1036		Show Fail: Cannot show an  while another  is showing
+            
+            if (Ads.context != null)
+            {
+                Ads.context.adCallback |= AdCallback.Fail;
+                Ads.context.onShowFailed?.Invoke();
+            } else
+            {
+                LogWarning("[Ad] OnAdShowFailed() Something wrong - No AdContext");
+            }
+        }
+
+        protected void OnAdShowSucceeded()
+        {
+            Log($"[Ad] {adType} OnAdShowSucceeded");
+
+            if (Ads.context != null)
+            {
+                Ads.context.adCallback |= AdCallback.Success;
+                Ads.context.onShowSuccess?.Invoke();
+            } else
+            {
+                LogWarning("[Ad] OnAdShowSucceeded() Something wrong - No AdContext");
+            }
+        }
+
+        protected void OnAdShowReadyStatus(bool isReady, AdShowReadyStatus status)
+        {
+            if (Ads.context == null)
+            {
+                LogWarning("[Ad] OnAdOpen() Something wrong - No AdContext");
+                return;
+            }
+
+            Ads.context.adCallback |= AdCallback.ShowReadyStatus;
+            Ads.context.onAdShowReadyStatus?.Invoke(status);
+            if (status == AdShowReadyStatus.Ready)
+            {
+                dispatcher.Dispatch(
+                    _isInterstitial ? AmaGDK.Event.INTER_SHOW_READY : AmaGDK.Event.REWARD_VIDEO_SHOW_READY
+                );
+            } else if (status == AdShowReadyStatus.NoInternet || status == AdShowReadyStatus.TimeOut || status == AdShowReadyStatus.Wifi3GDisabled)
+            {
+                dispatcher.Dispatch(
+                    _isInterstitial ? AmaGDK.Event.INTER_SHOW_NOT_READY : AmaGDK.Event.REWARD_VIDEO_SHOW_NOT_READY,
+                    status
+                );
+            }
+        }
+        
+        protected void OnAdOpen()
+        {
+            Log($"[Ad] {adType} OnAdOpen");
+
+            if (Ads.context != null)
+            {
+                Ads.context.adCallback |= AdCallback.Open;
+                Ads.context.onOpened?.Invoke();
+            } else
+            {
+                LogWarning("[Ad] OnAdOpen() Something wrong - No AdContext");
+            }
+        }
+
+        protected void OnAdReward()
+        {
+            Log($"[Ad] {adType} OnAdReward");
+
+            if (Ads.context != null)
+            {
+                Ads.context.adCallback |= AdCallback.Reward;
+                Ads.context.onRewardReceived?.Invoke();
+            } else
+            {
+                LogWarning("[Ad] OnAdReward() Something wrong - No AdContext");
+            }
+        }
+
+        protected void OnAdLoadSuccess()
+        {
+            Log($"[Ad] {adType} OnAdLoadSuccess");
+
+            if (!_isRequesting && adType == AdType.Interstitial)
+            {
+                LogWarning("[Ad] Something wrong? OnAdReady called when no ad is loading! AdType=" + adType);
+            }
+            
+            _isRequesting = false;
+        }
+        
+        protected void OnAdLoadFailed(string error)
+        {
+            Log($"[Ad] {adType} OnAdLoadFailed: {error}");
+            _isRequesting = false;
+        }
+    }
+}

package/Runtime/Ad/AdLogic.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 93ff7a3a45f2418a952e7509b78f101c
+timeCreated: 1719304407

package/Runtime/Ad/AdModuleConfig.cs

@@ -0,0 +1,39 @@
+using System;
+using UnityEngine;
+
+namespace Amanotes.Core.Internal
+{
+    [Serializable] public class AdModuleConfig
+    {
+        [Tooltip("Automatically retry requesting ad if an ad failed to response in this amount of time (in secs)")]
+        public int adLoadTimeoutInSecs = 30;
+        
+        [Tooltip("When an ad is not ready to show, keep waiting for this amount of time (in secs)\n\nIf the ad is ready during that time, it would be shown normally.")]
+        public int adShowTimeoutInSecs = 5;
+        
+        [Tooltip("When an ad is not ready to show, verify that there is an internet connection by ping the internet check URL .\nIf there is no internet connection, we will not need to wait for adShowTimeout secs")]
+        public bool checkInternet = true;
+                
+        [NonSerialized] public bool enableInterstitial = true;
+        [NonSerialized] public bool enableRewarded = true;
+        [NonSerialized] public bool enableBanner = true;
+        
+        [Tooltip("Before showing an ad: set AudioListener.volume to 0\nAfter the ad is closed: restore the previously saved AudioListener.volume")]
+        public bool autoMute = true;
+        
+        [Tooltip("Before showing an ad: set Time.timeScale to 0\nAfter the ad is closed: restore the previously saved Time.timeScale")]
+        public bool autoTimeScale = true;
+
+        [Tooltip("Preload banner right when Ad module init (default = false)")]
+        public bool preloadBanner = false;
+
+        [Header("EDITOR")]
+        [Tooltip("Only applicable in Editor\n0 = 0% success\n1 = 100% success")]
+        [Range(0f, 1f)] public float rewardAdShowSuccessRate = 1;
+    }
+
+    public partial class ConfigAsset
+    {
+        [SerializeField] public AdModuleConfig ad;
+    }
+}

package/Runtime/Ad/AdModuleConfig.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 45d2807333c94d48870dd9df18c9f91e
+timeCreated: 1719304327

package/Runtime/Ad/AdShowContext.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+namespace Amanotes.Core.Internal
+{
+    public class AdShowContext : IAdCallback
+    {
+        public readonly AdType adType;
+        public readonly string placementName;
+        public readonly Dictionary<string, object> userData;
+        public AdCallback adCallback;
+        
+        internal Action onBeforeAdOpen;
+        internal Action onOpened;
+        internal Action onRewardReceived;
+        internal Action onClicked;
+        internal Action onShowSuccess;
+        internal Action onShowFailed;
+        internal Action onClosed;
+        internal Action<AdShowReadyStatus> onAdShowReadyStatus;
+        internal Action<bool> onAdResult;
+
+        // Stats
+        public float showCallAt;
+        public float showFinishAt;
+        
+        public AdShowContext(AdType adType, string placementName, Dictionary<string, object> userData)
+        {
+            this.adType = adType;
+            this.userData = userData;
+            this.placementName = placementName;
+            adCallback = AdCallback.None;
+            showCallAt = Time.realtimeSinceStartup;
+            showFinishAt = 0;
+        }
+
+        public bool hasFailedOrCancelled => (adCallback & (AdCallback.Fail | AdCallback.Cancel)) != 0;
+        public bool potentiallyCompleted => (adCallback & (AdCallback.Close | AdCallback.Fail | AdCallback.Reward | AdCallback.Cancel)) != 0;
+        public bool hasReward => (adCallback & AdCallback.Reward) != 0;
+        public bool hasClosed => (adCallback & AdCallback.Close) != 0;
+        public bool hasClicked => (adCallback & AdCallback.Click) != 0;
+    }
+}

package/Runtime/Ad/AdShowContext.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1b163c41aa124983aad83068d46817db
+timeCreated: 1719304501