AdCallbackMessagesVerifier.cs

using System.Collections.Generic;
using UnityEngine;
 
namespace SCG.SpaceAdMobile
{
    public abstract class AdCallbackMessagesVerifier : MonoBehaviour
    {
#if UNITY_EDITOR
        // Prevent duplicate scheduling for the same instance.
#if UNITY_6000_4_OR_NEWER
        private static readonly HashSet<EntityId> pending = new();
#else
        private static readonly HashSet<int> pending = new();
#endif
 
        [SerializeField]
        [Tooltip("Automatically validates and adjusts the " + nameof(MessageOptions) +
            " based on the selected " + nameof(ValidateType) + " policy.")]
        protected MessageValidateType ValidateType = MessageValidateType.Full;
 
        protected virtual void OnValidate()
        {
            // Do not run in playmode; ignore prefab assets; ignore objects not in a loaded scene.
            if (!ValidateScript()) return;
 
            // Schedule a safe, editor-ready validation by instance id.
#if UNITY_6000_4_OR_NEWER
            ScheduleAfterEditorReady(GetEntityId());
#else
            ScheduleAfterEditorReady(GetInstanceID());
#endif
        }

        protected virtual void ValidateSafe()
        {
            if (!ValidateScript()) return;
 
            if (!TryGetComponent<AdUnitBase>(out var adUnit) || !adUnit)
            {
                Debug.LogWarning($"{nameof(AdUnitBase)} component not found on the GameObject '{name}'.", this);
                return;
            }
 
            if (ValidateType == MessageValidateType.None) return;
 
            ValidateMessageOptions(adUnit);
        }
 
        protected virtual bool ValidateScript()
        {
            if (!this || !gameObject) return false;
            var scn = gameObject.scene;
            return scn.IsValid() && scn.isLoaded && !Application.isPlaying;
        }
 
#if UNITY_6000_4_OR_NEWER
        private static void ScheduleAfterEditorReady(EntityId entityId)
        {
            if (!pending.Add(entityId)) return;
 
            UnityEditor.EditorApplication.delayCall += () =>
            {
                if (UnityEditor.EditorApplication.isUpdating || UnityEditor.EditorApplication.isCompiling)
                {
                    pending.Remove(entityId);
                    ScheduleAfterEditorReady(entityId);
                    return;
                }
 
                pending.Remove(entityId);
 
                var obj = UnityEditor.EditorUtility.EntityIdToObject(entityId) as AdCallbackMessagesVerifier;
                if (!obj || !obj.gameObject) return;
 
                var scn = obj.gameObject.scene;
                if (!scn.IsValid() || !scn.isLoaded) return;
 
                obj.ValidateSafe();
            };
        }
#else
        private static void ScheduleAfterEditorReady(int instanceId)
        {
            // throttle duplicates
            if (!pending.Add(instanceId)) return;
 
            UnityEditor.EditorApplication.delayCall += () =>
            {
                if (UnityEditor.EditorApplication.isUpdating || UnityEditor.EditorApplication.isCompiling)
                {
                    pending.Remove(instanceId);
                    ScheduleAfterEditorReady(instanceId);
                    return;
                }
 
                pending.Remove(instanceId);
 
                var obj = UnityEditor.EditorUtility.InstanceIDToObject(instanceId) as AdCallbackMessagesVerifier;
                if (!obj || !obj.gameObject) return;
 
                var scn = obj.gameObject.scene;
                if (!scn.IsValid() || !scn.isLoaded) return;
 
                obj.ValidateSafe();
            };
        }
#endif

        protected virtual void ValidateMessageOptions(AdUnitBase adUnit)
        {
            adUnit.MessageOptions.AdPaid = CheckByType<IAdPaidMessage>(adUnit.MessageOptions.AdPaid);
            adUnit.MessageOptions.AdImpressionRecorded = CheckByType<IAdImpressionRecordedMessage>(adUnit.MessageOptions.AdImpressionRecorded);
            adUnit.MessageOptions.AdLoaded = CheckByType<IAdLoadedMessage>(adUnit.MessageOptions.AdLoaded);
            adUnit.MessageOptions.AdLoadFailed = CheckByType<IAdLoadFailedMessage>(adUnit.MessageOptions.AdLoadFailed);
            adUnit.MessageOptions.AdClicked = CheckByType<IAdClickedMessage>(adUnit.MessageOptions.AdClicked);
            adUnit.MessageOptions.AdShown = CheckByType<IAdShownMessage>(adUnit.MessageOptions.AdShown);
            adUnit.MessageOptions.AdClosed = CheckByType<IAdClosedMessage>(adUnit.MessageOptions.AdClosed);
            adUnit.MessageOptions.AdContentFailed = CheckByType<IAdContentFailedMessage>(adUnit.MessageOptions.AdContentFailed);
            adUnit.MessageOptions.AdReward = CheckByType<IAdRewardMessage>(adUnit.MessageOptions.AdReward);
        }

        protected bool CheckByType<T>(bool value)
             => ValidateType == MessageValidateType.Full ? this is T : this is T || value;
#endif
    }

    public enum MessageValidateType
    {
        [Tooltip("Validates and adjusts the message options fully, setting them either to true" + "\n" +
            "or false based on compatibility with the verifier type.")]
        Full,
        [Tooltip("Enables the message options that are compatible with the verifier type, without disabling any options.")]
        Enable,
        [Tooltip("Performs no automatic adjustments on the message options.")]
        None
    }
}