AdAggregatorSelector.Install.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using UnityEditor;
using UnityEditor.Compilation;
using UnityEngine;
using PackageInfo = UnityEditor.PackageManager.PackageInfo;
 
namespace SCG.SpaceAdMobile
{
    public partial class AdAggregatorSelector
    {
        private const string PackageManagerWindowGeneralMenu = "Window/General/Package Manager";
        private const string PackageManagerWindowLegacyMenu = "Window/Package Manager";
        private const string ServicesWindowMenu = "Window/Services/";
 
        private static readonly string[] packageManagerMenus =
        {
            PackageManagerWindowGeneralMenu,
            PackageManagerWindowLegacyMenu
        };
 
        #region Install Helpers
        private static Aggregator GetSelectedAggregator() =>
            (adAggregatorResource ? adAggregatorResource : AdAggregatorResource.Instance)
            .Aggregators == null ? null :
            selectedAggregator >= adAggregatorResource.Aggregators.Length ? null :
            adAggregatorResource.Aggregators[selectedAggregator];
 
        private static bool IsInstallActionConfigured(Aggregator aggregator)
        {
            var install = aggregator?.Install;
            if (install == null)
                return false;
 
            return install.InstallMode != InstallOpenMode.ExternalUrl ||
                   !string.IsNullOrWhiteSpace(install.InstallUrl);
        }
 
        private static void OpenInstall(Aggregator aggregator)
        {
            if (aggregator == null)
                return;
 
            var install = aggregator.Install;
            if (install == null)
            {
                Debug.LogWarning($"[{nameof(AdAggregatorSelector)}] Install resource is missing for '{aggregator.Name}'.");
                return;
            }
 
            if (install.InstallMode == InstallOpenMode.PackageManager)
            {
                if (TryOpenPackageManager(install))
                    return;
 
                if (!string.IsNullOrWhiteSpace(install.InstallUrl))
                {
                    Application.OpenURL(install.InstallUrl);
                    return;
                }
 
                Debug.LogWarning(
                    $"[{nameof(AdAggregatorSelector)}] Package Manager is unavailable and fallback URL is missing for '{aggregator.Name}'.");
                return;
            }
 
            if (!string.IsNullOrWhiteSpace(install.InstallUrl))
            {
                Application.OpenURL(install.InstallUrl);
                return;
            }
 
            Debug.LogWarning($"[{nameof(AdAggregatorSelector)}] Install URL is missing for '{aggregator.Name}'.");
        }
 
        private static bool TryOpenPackageManager(AggregatorInstallResource install)
        {
            if (install == null)
                return false;
 
            if (TryOpenPackageManagerByPackageId(install.InstallPackageIds))
                return true;
 
            var menuItems = new List<string>();
            if (!string.IsNullOrWhiteSpace(install.PackageManagerFilter))
            {
                menuItems.Add(ServicesWindowMenu + install.PackageManagerFilter);
            }
 
            menuItems.AddRange(packageManagerMenus);
            return menuItems
                .Where(menuItem => !string.IsNullOrWhiteSpace(menuItem))
                .Distinct(StringComparer.Ordinal)
                .Any(EditorApplication.ExecuteMenuItem);
        }
 
        private static bool TryOpenPackageManagerByPackageId(IEnumerable<string> packageIds)
        {
            var enumerable = packageIds as string[] ?? packageIds.ToArray();
            if (!HasValues(enumerable))
                return false;
 
            var packageManagerWindowType = FindPackageManagerWindowType();
            if (packageManagerWindowType == null)
                return false;
 
            var openMethod = packageManagerWindowType.GetMethod(
                "Open",
                BindingFlags.Public | BindingFlags.Static,
                null,
                new[] { typeof(string) },
                null);
            if (openMethod == null)
                return false;
 
            foreach (var packageId in enumerable.Where(id => !string.IsNullOrWhiteSpace(id)))
            {
                try
                {
                    openMethod.Invoke(null, new object[] { packageId });
                    return true;
                }
                catch
                {
                    // Ignore reflection invocation errors and continue with fallbacks.
                }
            }
 
            return false;
        }
 
        private static Type FindPackageManagerWindowType()
        {
            const string fullTypeName = "UnityEditor.PackageManager.UI.Window";
 
            var type = Type.GetType($"{fullTypeName}, UnityEditor");
            if (type != null)
                return type;
 
            return AppDomain.CurrentDomain.GetAssemblies()
                .Select(assembly => assembly.GetType(fullTypeName, throwOnError: false))
                .FirstOrDefault(foundType => foundType != null);
        }
 
        private static bool IsAggregatorInstalled(Aggregator aggregator)
        {
            var install = aggregator?.Install;
            if (install == null)
                return true;
 
            var hasChecks = false;
 
            if (HasValues(install.InstallPackageIds))
            {
                hasChecks = true;
                if (install.InstallPackageIds.Any(IsPackageInstalled))
                    return true;
            }
 
            if (HasValues(install.InstallFolderNames))
            {
                hasChecks = true;
                if (install.InstallFolderNames.Any(IsFolderInstalled))
                    return true;
            }
 
            if (!HasValues(install.InstallAssemblyNames)) return !hasChecks;
            return install.InstallAssemblyNames.Any(IsAssemblyInstalled);
        }
 
        private static bool IsPackageInstalled(string packageId)
        {
            if (string.IsNullOrWhiteSpace(packageId))
                return false;
 
            if (IsPackageDefinedInManifest(packageId))
                return true;
 
            try
            {
                return PackageInfo.FindForAssetPath($"Packages/{packageId}") != null;
            }
            catch
            {
                return false;
            }
        }
 
        private static bool IsPackageDefinedInManifest(string packageId)
        {
            if (string.IsNullOrWhiteSpace(packageId))
                return false;
 
            var manifestPath = Path.Combine(GetProjectRootPath(), "Packages", "manifest.json");
            if (!File.Exists(manifestPath))
                return false;
 
            try
            {
                var manifest = File.ReadAllText(manifestPath);
                return manifest.Contains($"\"{packageId}\"", StringComparison.Ordinal);
            }
            catch
            {
                return false;
            }
        }
 
        private static bool IsFolderInstalled(string folderName)
        {
            if (string.IsNullOrWhiteSpace(folderName))
                return false;
 
            var normalizedFolder = folderName.Replace('\\', '/').Trim('/');
            if (string.IsNullOrWhiteSpace(normalizedFolder))
                return false;
 
            var candidateAssetFolders = new[]
            {
                normalizedFolder,
                $"Assets/{normalizedFolder}",
                $"Packages/{normalizedFolder}"
            };
            if (candidateAssetFolders.Any(AssetDatabase.IsValidFolder))
                return true;
 
            var projectRoot = GetProjectRootPath();
            var candidateDiskFolders = new[]
            {
                Path.Combine(projectRoot, normalizedFolder),
                Path.Combine(projectRoot, "Assets", normalizedFolder),
                Path.Combine(projectRoot, "Packages", normalizedFolder)
            };
            return candidateDiskFolders.Any(Directory.Exists);
        }
 
        private static bool IsAssemblyInstalled(string assemblyName)
        {
            if (string.IsNullOrWhiteSpace(assemblyName))
                return false;
 
            try
            {
                return CompilationPipeline.GetAssemblies().Any(assembly =>
                    string.Equals(assembly.name, assemblyName, StringComparison.OrdinalIgnoreCase));
            }
            catch
            {
                return AppDomain.CurrentDomain.GetAssemblies().Any(assembly =>
                    string.Equals(assembly.GetName().Name, assemblyName, StringComparison.OrdinalIgnoreCase));
            }
        }
 
        private static bool HasValues(IEnumerable<string> values) =>
            values != null && values.Any(value => !string.IsNullOrWhiteSpace(value));
 
        private static string GetProjectRootPath() =>
            Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
        #endregion
    }
}