AdUnit.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
namespace SCG.SpaceAdMobile
{
    public abstract class AdUnit<TAd> : AdUnitHandlerBase
    {
        public TAd AdObject { get; protected set; }
 
        [SerializeField]
        [Tooltip("Ad unit ID for Android.")]
        private string androidId;
        [SerializeField]
        [Tooltip("Ad unit ID for iOS.")]
        private string iOSId;
 
        [SerializeField]
        [Tooltip("Behavior options for displaying and showing ads.")]
        private AdBehaviour adBehaviour = new();
 
        [SerializeField]
        [Tooltip("Options for enabling Unity SendMessage methods.")]
        private MessageOptions messageOptions = new();

        public override AdBehaviour AdBehaviour => adBehaviour;
        public override MessageOptions MessageOptions => messageOptions;

        public virtual AdvertisingOptions Options
        {
            get => SpaceAdMobileBase.Options;
            set => SpaceAdMobileBase.Options = value;
        }

        public virtual IInternetConnectionChecker InternetConnection
        {
            get => SpaceAdMobileBase.InternetConnection;
            set => SpaceAdMobileBase.InternetConnection = value;
        }

        public virtual LogOptions LogOptions => Options.LogOptions;

        protected SpaceAdLogger Logger { get; private set; }

        protected virtual bool ShouldUnloadOnLoad => true;

        protected virtual bool ShouldUnloadOnShow => false;

        protected abstract bool SdkInitialized { get; }

        protected Type SystemAdType { get; private set; }
        protected string SystemAdTypeName { get; private set; }

        private static readonly Dictionary<string, TAd> cachedAdUnits = new();
 
        private bool wasShown;
        private bool wasAwakened;

        protected override void Awake()
        {
            SystemAdType = typeof(TAd);
            SystemAdTypeName = SystemAdType.Name;
            Logger = InitLogger();
 
            Options ??= !Application.isEditor
                ? throw new UnityException($"The {nameof(SpaceAdMobileBase)} script must be added to the first scene.")
                : new();
 
#if !DEBUG
            var debug = false;
#else
            var debug = Options.AdMode != AdMode.Development;
#endif
            if (debug && RuntimePlatformGuard.IsRuntimePlatformSupported &&
                string.IsNullOrEmpty(androidId) && string.IsNullOrEmpty(iOSId))
            {
                throw new UnityException("At least one ID is required, but both Android and iOS IDs are empty!");
            }
 
            UnityAwake();
            wasAwakened = true;
        }

        protected override void OnEnable()
        {
            if (!RuntimePlatformGuard.IsRuntimePlatformSupported) return;
 
            if (AdBehaviour.AutoLoadOnEnable)
            {
                if (!SdkInitialized && Options.AwaitSDKInitialization)
                {
                    IEnumerator WaitForReady()
                    {
                        yield return new WaitWhile(() => !SdkInitialized);
                        Load();
                    }
 
                    StartCoroutine(WaitForReady());
                }
                else
                {
                    Load();
                }
            }
 
            UnityOnEnable();
        }

        protected override void OnDestroy()
        {
            ReleaseFullscreenAdAudio();
            base.OnDestroy();
            //Unity OnApplicationQuit
            if (Options == null)
                return;
 
            //If cache is active and ad has not been shown, it can be shown later.
            //Last verification is for Test IDs that contain the same IDs.
            if (Options.CacheAds && CanShowAd() && !cachedAdUnits.ContainsKey(GetId()))
            {
                cachedAdUnits.Add(GetId(), AdObject);
                OnAttachToCache();
            }
            else
            {
                Unload();
            }
 
            UnityOnDestroy();
        }

        protected override void OnApplicationQuit()
        {
            Unload();
            cachedAdUnits.Clear();
            UnityOnApplicationQuit();
        }

        public override bool Load() => TryPrepareLoad() && LoadInternal();

        protected bool TryPrepareLoad()
        {
            EnsureScriptReady();
 
            if (!RuntimePlatformGuard.EnsureSupported()) return false;
 
            if (Options.CacheAds && cachedAdUnits.ContainsKey(GetId()))
            {
                Logger.Log(LogOptions.AdCachedLoadLogText);
                AdObject = cachedAdUnits[GetId()];
                OnLoadFromCache();
                OnAdLoaded();
                cachedAdUnits.Remove(GetId());
                return false;
            }
 
            if (ShouldUnloadOnLoad)
                Unload();
 
            if (!SdkInitialized && Options.AwaitSDKInitialization)
            {
                Logger.LogWarning(LogOptions.SdkNotInitializedLogText);
                return false;
            }
 
            if (InternetConnection.CheckInternetConnection()) return true;
 
            Logger.LogWarning(LogOptions.NoInternetLogText);
            OnInternetNotAvailable();
            return false;
        }

        private protected override void OnAdLoadedInternal() => wasShown = false;

        public override bool CanShowAd() =>
            RuntimePlatformGuard.IsRuntimePlatformSupported &&
            AdObject != null &&
            (!ShouldUnloadOnShow || !wasShown);

        public override void Show()
        {
            EnsureScriptReady();
 
            if (!RuntimePlatformGuard.EnsureSupported()) return;
 
            if (AdObject != null && CanShowAd())
            {
                if (ShouldUnloadOnShow) wasShown = true;
 
                Logger.Log(LogOptions.AdShowingLogText);
                AcquireFullscreenAdAudioLease();
                try
                {
                    ShowInternal();
                }
                catch
                {
                    ReleaseFullscreenAdAudio();
                    throw;
                }
            }
            else
            {
                if (AdBehaviour.LoadOnDemand)
                {
                    Logger.Log(LogOptions.AdUnavailableLogText);
                    Load();
                }
                else
                {
                    Logger.LogWarning(LogOptions.AdUnavailableLogText);
                }
            }
        }

        public override void Unload()
        {
            ReleaseFullscreenAdAudio();
 
            if (AdObject == null)
            {
                wasShown = false;
                return;
            }
 
            OnUnload();
            DestroyInternal();
            AdObject = default;
            wasShown = false;
        }
 
        private void EnsureScriptReady()
        {
            if (!wasAwakened)
                throw new InvalidOperationException("The script is not ready yet. Wait until Awake has completed before calling this method.");
 
            if (SystemAdType == null)
                throw new InvalidOperationException("The component is not initialized yet. Enable it before calling this method.");
        }

        protected abstract bool LoadInternal();

        protected abstract SpaceAdLogger InitLogger();

        protected internal string GetRealId() =>
            RuntimePlatformGuard.GetAdUnitId(androidId, iOSId);

        protected string GetId() =>
            RuntimePlatformGuard.GetAdUnitId(
                Options.AdMode == AdMode.Development ? TestAndroidId : androidId,
                Options.AdMode == AdMode.Development ? TestIOSId : iOSId);
    }
}