AdAggregatorResource.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEngine;
using Object = UnityEngine.Object;
 
namespace SCG.SpaceAdMobile
{
    // For Core Developers Only
    // [CreateAssetMenu(fileName = nameof(AdAggregatorResource), menuName = nameof(SCG) + "/" + "Create " + nameof(AdAggregatorResource))]
    public class AdAggregatorResource : ScriptableObject
    {
        #region Validation sync
 
#if UNITY_6000_4_OR_NEWER
        private static readonly HashSet<EntityId> pendingValidationInstanceIds = new();
#else
        private static readonly HashSet<int> pendingValidationInstanceIds = new();
#endif
        private static bool isSynchronizingAggregators;
 
        #endregion

        public static AdAggregatorResource Instance
        {
            get
            {
                if (instance != null) return instance;
 
                instance = Resources.Load<AdAggregatorResource>(nameof(AdAggregatorResource));
                return instance;
            }
        }
        private static AdAggregatorResource instance;

        public const string KeyDeleteOtherFolders = nameof(SpaceAdMobile) + "." + nameof(DeleteOtherFolders);
        public const string KeyDeleteDemo = nameof(SpaceAdMobile) + "." + nameof(DeleteDemo);
        public const string KeyDeleteDocumentation = nameof(SpaceAdMobile) + "." + nameof(DeleteDocumentation);
        public const string KeyUseEnhancedYandexEditorDummies = nameof(SpaceAdMobile) + "." + nameof(UseEnhancedYandexEditorDummies);

        public bool IsFreeVersion;

        public bool DeleteOtherFolders;
        public bool DeleteDemo;
        public bool DeleteDocumentation;

        [Tooltip("Controls whether enhanced Yandex editor dummies are generated and applied.")]
        public bool UseEnhancedYandexEditorDummies;

        [Tooltip("Folder names to exclude when scanning for scripts (matched by path segments, case-insensitive).")]
        public string[] ExcludedFolderNames =
        {
            "Prefabs",
            "Democumentation", "Demo", "Documentation",
            "Data"
        };

        public Aggregator[] Aggregators;

        public YandexData Yandex;

        [TextArea(20, 50)]
        public string WelcomeText;

        protected void OnValidate()
        {
#if !UPM_PACKAGE && UNITY_ASTOOLS_EXPERIMENTAL
            if (!this || Aggregators == null)
                return;
 
            // AssetDatabase queries are unsafe while the editor is refreshing/importing assets.
            if (EditorApplication.isUpdating || EditorApplication.isCompiling)
            {
#if UNITY_6000_4_OR_NEWER
                ScheduleSynchronization(GetEntityId());
#else
                ScheduleSynchronization(GetInstanceID());
#endif
                return;
            }
 
            SynchronizeAggregators();
#endif
 
#if LEGACY_YANDEX_MOBILE_ADS
            if (UseEnhancedYandexEditorDummies) UseEnhancedYandexEditorDummies = false;
#endif
        }

        protected virtual void OnDestroy() => instance = null;
 
        #region Validation sync
 
        private void SynchronizeAggregators()
        {
            if (isSynchronizingAggregators || Aggregators == null)
                return;
 
            isSynchronizingAggregators = true;
 
            try
            {
                var anyChanged = false;
 
                foreach (var aggregator in Aggregators)
                {
                    var newList = CollectHelper.CollectScriptsForAggregator(aggregator, ExcludedFolderNames);
                    var newPrefabs = CollectHelper.CollectPrefabsForAggregator(aggregator);
 
                    if (!CollectHelper.ArraysEqual(aggregator.Migrations, newList))
                    {
                        aggregator.Migrations = newList;
                        anyChanged = true;
                    }
 
                    if (!CollectHelper.ArraysEqual(aggregator.Prefabs, newPrefabs))
                    {
                        aggregator.Prefabs = newPrefabs;
                        anyChanged = true;
                    }
                }
 
                if (!anyChanged)
                    return;
 
                EditorUtility.SetDirty(this);
                AssetDatabase.SaveAssets();
            }
            finally
            {
                isSynchronizingAggregators = false;
            }
        }
 
#if !UPM_PACKAGE && UNITY_ASTOOLS_EXPERIMENTAL
#if UNITY_6000_4_OR_NEWER
        private static void ScheduleSynchronization(EntityId entityId)
        {
            if (!pendingValidationInstanceIds.Add(entityId))
                return;
 
            EditorApplication.delayCall += () =>
            {
                if (EditorApplication.isUpdating || EditorApplication.isCompiling)
                {
                    pendingValidationInstanceIds.Remove(entityId);
                    ScheduleSynchronization(entityId);
                    return;
                }
 
                pendingValidationInstanceIds.Remove(entityId);
 
                var resource = EditorUtility.EntityIdToObject(entityId) as AdAggregatorResource;
                if (!resource)
                    return;
 
                resource.SynchronizeAggregators();
            };
        }
#else
        private static void ScheduleSynchronization(int instanceId)
        {
            if (!pendingValidationInstanceIds.Add(instanceId))
                return;
 
            EditorApplication.delayCall += () =>
            {
                if (EditorApplication.isUpdating || EditorApplication.isCompiling)
                {
                    pendingValidationInstanceIds.Remove(instanceId);
                    ScheduleSynchronization(instanceId);
                    return;
                }
 
                pendingValidationInstanceIds.Remove(instanceId);
 
                var resource = EditorUtility.InstanceIDToObject(instanceId) as AdAggregatorResource;
                if (!resource)
                    return;
 
                resource.SynchronizeAggregators();
            };
        }
#endif
#endif
 
        #endregion
    }

    [Serializable]
    public class Aggregator
    {
        public string Name;
        public string ShortName;
        public Texture2D Texture;
        public string Define;
        public Object Folder;
        public string DemoFolderName;

        public MonoScript[] Migrations;
        public GameObject[] Prefabs;

        [Tooltip("Install configuration used by the selector to detect SDK presence and open install flows.")]
        public AggregatorInstallResource Install = new();
    }

    public enum InstallOpenMode : byte
    {
        ExternalUrl = 0,

        PackageManager = 1
    }

    [Serializable]
    public class AggregatorInstallResource
    {
        [Tooltip("Determines how the Install action is opened for this aggregator.")]
        public InstallOpenMode InstallMode = InstallOpenMode.ExternalUrl;

        [Tooltip("External installation URL opened when InstallMode is ExternalUrl.")]
        public string InstallUrl;

        [Tooltip("Package IDs used for install checks and Package Manager deep links.")]
        public string[] InstallPackageIds = Array.Empty<string>();

        [Tooltip("Folder names used to detect installed SDK files in Assets or Packages.")]
        public string[] InstallFolderNames = Array.Empty<string>();

        [Tooltip("Assembly names used to detect installed SDK assemblies in the editor domain.")]
        public string[] InstallAssemblyNames = Array.Empty<string>();

        [Tooltip("Optional Package Manager filter or section label for the Install action.")]
        public string PackageManagerFilter;
    }

    [Serializable]
    public class YandexData
    {
        public Object Asmdef;
        public string AssetPath = "YandexMobileAds";
        public string EditorPath = "YandexMobileAds/Editor";

        public string MainAsmdefName = "YandexMobileAds";
        public string EditorAsmdefName = "YandexMobileAds.Editor";

        public string RemoveDefineConstraint = "YANDEX_ASMDEF_NONEXISTENT";

        [TextArea(15, 30)]
        public string AsmdefTemplate =
@"{
    ""name"": ""YandexMobileAds"",
    ""rootNamespace"": ""YandexMobileAds"",
    ""references"": [
        ""AppMetricaAdRevenueAdapter""
    ],
    ""includePlatforms"": [],
    ""excludePlatforms"": [],
    ""allowUnsafeCode"": true,
    ""overrideReferences"": false,
    ""precompiledReferences"": [],
    ""autoReferenced"": false,
    ""defineConstraints"": [],
    ""versionDefines"": [],
    ""noEngineReferences"": false
}";

        [TextArea(20, 30)]
        public string AsmdefEditorTemplate =
@"{
    ""name"": ""YandexMobileAds.Editor"",
    ""rootNamespace"": """",
    ""references"": [
        ""YandexMobileAds""
    ],
    ""includePlatforms"": [
        ""Editor""
    ],
    ""excludePlatforms"": [],
    ""allowUnsafeCode"": false,
    ""overrideReferences"": false,
    ""precompiledReferences"": [],
    ""autoReferenced"": true,
    ""defineConstraints"": [
        ""YANDEX_MOBILE_ADS""
    ],
    ""versionDefines"": [],
    ""noEngineReferences"": false
}";

        [Tooltip("C# source template for the enhanced rewarded ad editor dummy.")]
        [TextArea(20, 50)]
        public string RewardedDummyTemplate;

        [Tooltip("C# source template for the enhanced interstitial ad editor dummy.")]
        [TextArea(20, 50)]
        public string InterstitialDummyTemplate;

        [Tooltip("C# source template for the enhanced app-open ad editor dummy.")]
        [TextArea(20, 50)]
        public string AppOpenDummyTemplate;

        [Tooltip("C# source template for the enhanced banner client editor dummy.")]
        [TextArea(20, 50)]
        public string BannerDummyTemplate;
    }
 
    internal static class CollectHelper
    {
        private static readonly StringComparer pathComparer = StringComparer.OrdinalIgnoreCase;

        public static MonoScript[] CollectScriptsForAggregator(Aggregator aggregator, IList<string> excludedNames)
        {
            var scripts = new List<MonoScript>();
 
            if (aggregator?.Folder == null)
                return scripts.ToArray();
 
            var folderPath = AssetDatabase.GetAssetPath(aggregator.Folder);
            if (string.IsNullOrEmpty(folderPath))
                return scripts.ToArray();
 
            // If a file was assigned instead of a folder, use its directory.
            if (!AssetDatabase.IsValidFolder(folderPath))
                folderPath = Path.GetDirectoryName(folderPath)?.Replace('\\', '/') ?? folderPath;
 
            if (string.IsNullOrEmpty(folderPath) || !AssetDatabase.IsValidFolder(folderPath))
                return scripts.ToArray();
 
            var guids = AssetDatabase.FindAssets("t:MonoScript", new[] { folderPath });
            scripts.AddRange(
                from guid
                in guids
                select AssetDatabase.GUIDToAssetPath(guid)
                into path
                where path.EndsWith(".cs", StringComparison.OrdinalIgnoreCase)
                where !IsPathExcluded(path, excludedNames)
                select AssetDatabase.LoadAssetAtPath<MonoScript>(path)
                into ms
                where ms != null
                select ms);
 
            // Stable order: by file name, then by full path.
            return scripts
                .OrderBy(ms => Path.GetFileNameWithoutExtension(AssetDatabase.GetAssetPath(ms)), pathComparer)
                .ThenBy(AssetDatabase.GetAssetPath, pathComparer)
                .ToArray();
        }

        public static GameObject[] CollectPrefabsForAggregator(Aggregator aggregator, string prefabsFolderName = "Prefabs")
        {
            // Return empty if folder ref is missing
            if (aggregator?.Folder == null)
                return Array.Empty<GameObject>();
 
            // Resolve base folder path
            var basePath = AssetDatabase.GetAssetPath(aggregator.Folder);
            if (string.IsNullOrEmpty(basePath))
                return Array.Empty<GameObject>();
 
            // If a file was assigned, use its directory
            if (!AssetDatabase.IsValidFolder(basePath))
                basePath = Path.GetDirectoryName(basePath)?.Replace('\\', '/') ?? basePath;
 
            if (string.IsNullOrEmpty(basePath) || !AssetDatabase.IsValidFolder(basePath))
                return Array.Empty<GameObject>();
 
            // Build "<base>/Prefabs" path
            var prefabsPath = $"{basePath.TrimEnd('/')}/{prefabsFolderName}";
 
            // If direct subfolder is missing, try to locate any subfolder named exactly "prefabsFolderName"
            if (!AssetDatabase.IsValidFolder(prefabsPath))
            {
                // Search for folders under basePath and pick the first that matches by last segment
                var folderGuids = AssetDatabase.FindAssets("t:Folder", new[] { basePath });
                var match = folderGuids
                    .Select(AssetDatabase.GUIDToAssetPath)
                    .FirstOrDefault(p => pathComparer.Equals(Path.GetFileName(p.TrimEnd('/')), prefabsFolderName));
 
                if (match == null || !AssetDatabase.IsValidFolder(match))
                    return Array.Empty<GameObject>();
 
                prefabsPath = match;
            }
 
            // Find prefabs only inside the resolved Prefabs folder
            var guids = AssetDatabase.FindAssets("t:Prefab", new[] { prefabsPath });
 
            var list = new List<GameObject>(guids.Length);
            list.AddRange(
                from guid
                in guids
                select AssetDatabase.GUIDToAssetPath(guid)
                into path
                where path.EndsWith(".prefab", StringComparison.OrdinalIgnoreCase)
                select AssetDatabase.LoadAssetAtPath<GameObject>(path)
                into go
                where go != null
                select go);
 
            // Stable order: by name, then by full path
            return list
                .OrderBy(go => go.name, pathComparer)
                .ThenBy(AssetDatabase.GetAssetPath, pathComparer)
                .ToArray();
        }

        private static bool IsPathExcluded(string assetPath, IList<string> excludedNames)
        {
            if (excludedNames == null || excludedNames.Count == 0) return false;
 
            var normalized = assetPath.Replace('\\', '/');
            var segments = normalized.Split('/');
 
            // Check only directory segments, not the file name (last segment).
            for (var i = 0; i < segments.Length - 1; i++)
            {
                var seg = segments[i];
                if (excludedNames.Any(t => pathComparer.Equals(seg, t)))
                {
                    return true;
                }
            }
            return false;
        }
 
        public static bool ArraysEqual<T>(T[] a, T[] b) where T : Object
        {
            if (ReferenceEquals(a, b)) return true;
            if (a == null || b == null) return false;
            if (a.Length != b.Length) return false;
            return !a.Where((t, i) => t != b[i]).Any();
        }
    }
}