com.amanotes.gdk 0.2.51 → 0.2.53

package/CHANGELOG.md

@@ -1,16 +1,22 @@
 # Changelog
 
-## [0.2.51 - 2024-02-23]
-- New feature: GDKCIBuildCommand
-- [Dev] Change Google Mobile Ads SDK version for iOS, 10.9 -> 10.5.0
-- [Analytics] Add LogEventImmediately()
-- [Analytics] Move AddParam() to internal use
-- [Analytics] Replace event Queue by ConcurrentQueue
-- [Ads] Check null Ads._adapter
-- [Ads] Autostart AdEventTracking
-- [Analytics] Update AppsFlyer adapter version
-- [UserProfile] Change logic of getting ama_device_id
-- [Core] Init modules before Hooks
+## [0.2.53 - 2024-03-14]
+- Add FirebaseCrashlyticsHook
+- Fix Change to dev mode
+- Public analytics config
+- Update SDK version tracking
+- Update GDKLocalBuild
+
+## [0.2.52 - 2024-02-27]
+- Change post processing order
+- Remove GDKInstaller after installed
+- Enable pipeline execution for branches with active merge requests
+- [Fix] Non-fatal exceptions relate to Analytics and Ads
+- Update Google Sheet Id default
+- Optimize GC for Analytics
+
+## [0.2.51 - 2024-02-20]
+- Change Google Mobile Ads SDK version , iosPod 10.5.0
 
 ## [0.2.50 - 2024-02-20]
 - New feature: Modify Android post processor

package/Editor/AmaGDKEditor.cs

@@ -180,7 +180,7 @@ namespace Amanotes.Editor
             {
                 if (GUILayout.Button(ObjectNames.NicifyVariableName(extra)))
                 {
-                    var package = $"{Res.PACKAGE_PATH}{extra}";
+                    var package = $"{Res.EXTRA_PATH}{extra}";
                     AssetDatabase.ImportPackage(package, false);
                 }
             }
@@ -393,10 +393,14 @@ namespace Amanotes.Editor
                 {
                     string adapterName = FindBestAdapterFor(adapterId);
                     var package = $"{Res.PACKAGE_PATH}{adapterName}";
-                    if (GUILayout.Button(GetGUIContent($"Import {adapterId} Adapter"), GUILayout.Height(24f)))
+                    EditorGUI.BeginDisabledGroup(!status.sdkInstalled);
                     {
-                        AssetDatabase.ImportPackage(package, false);
+                        if (GUILayout.Button(GetGUIContent($"Import {adapterId} Adapter"), GUILayout.Height(24f)))
+                        {
+                            AssetDatabase.ImportPackage(package, false);
+                        }    
                     }
+                    EditorGUI.EndDisabledGroup();
                 }
 
             }, () =>
@@ -412,7 +416,7 @@ namespace Amanotes.Editor
                     Color c = GUI.color;
                     GUI.color = Color.yellow;
                     
-                    float w = EditorStyles.label.CalcSize(label).x;
+                    float w = EditorStyles.label.CalcSize(label).x+5f;
                     GUILayout.Label(label, GUILayout.Width(w));
                     GUI.color = c;
                 }

package/Editor/Extra/GDKCIBuildCommand.cs

@@ -0,0 +1,354 @@
+using UnityEditor;
+using System.Linq;
+using System;
+using System.IO;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public static class GDKCIBuildCommand
+    {
+        private const string KEYSTORE_PASS = "KEYSTORE_PASS";
+        private const string KEY_ALIAS_PASS = "KEY_ALIAS_PASS";
+        private const string KEY_ALIAS_NAME = "KEY_ALIAS_NAME";
+        private const string KEYSTORE = "keystore.keystore";
+        private const string BUILD_OPTIONS_ENV_VAR = "BuildOptions";
+        private const string ANDROID_BUNDLE_VERSION_CODE = "VERSION_BUILD_VAR";
+        private const string ANDROID_APP_BUNDLE = "BUILD_APP_BUNDLE";
+        private const string SCRIPTING_BACKEND_ENV_VAR = "SCRIPTING_BACKEND";
+        private const string VERSION_NUMBER_VAR = "VERSION_NUMBER_VAR";
+        private const string VERSION_iOS = "VERSION_BUILD_VAR";
+
+        static string GetArgument(string name)
+        {
+            string[] args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i].Contains(name))
+                {
+                    return args[i + 1];
+                }
+            }
+            return null;
+        }
+
+        static string[] GetEnabledScenes()
+        {
+            return (
+                from scene in EditorBuildSettings.scenes
+                where scene.enabled
+                where !string.IsNullOrEmpty(scene.path)
+                select scene.path
+            ).ToArray();
+        }
+
+        static BuildTarget GetBuildTarget()
+        {
+            string buildTargetName = GetArgument("customBuildTarget");
+            Console.WriteLine(":: Received customBuildTarget " + buildTargetName);
+
+            if (buildTargetName.ToLower() == "android")
+            {
+#if !UNITY_5_6_OR_NEWER
+			// https://issuetracker.unity3d.com/issues/buildoptions-dot-acceptexternalmodificationstoplayer-causes-unityexception-unknown-project-type-0
+			// Fixed in Unity 5.6.0
+			// side effect to fix android build system:
+			EditorUserBuildSettings.androidBuildSystem = AndroidBuildSystem.Internal;
+#endif
+            }
+
+            if (buildTargetName.TryConvertToEnum(out BuildTarget target))
+                return target;
+
+            Console.WriteLine($":: {nameof(buildTargetName)} \"{buildTargetName}\" not defined on enum {nameof(BuildTarget)}, using {nameof(BuildTarget.NoTarget)} enum to build");
+
+            return BuildTarget.NoTarget;
+        }
+
+        static string GetBuildPath()
+        {
+            string buildPath = GetArgument("customBuildPath");
+            Console.WriteLine(":: Received customBuildPath " + buildPath);
+            if (buildPath == "")
+            {
+                throw new Exception("customBuildPath argument is missing");
+            }
+            return buildPath;
+        }
+
+        static string GetBuildName()
+        {
+            string buildName = GetArgument("customBuildName");
+            Console.WriteLine(":: Received customBuildName " + buildName);
+            if (buildName == "")
+            {
+                throw new Exception("customBuildName argument is missing");
+            }
+            return buildName;
+        }
+
+        static string GetFixedBuildPath(BuildTarget buildTarget, string buildPath, string buildName)
+        {
+            if (buildTarget.ToString().ToLower().Contains("windows"))
+            {
+                buildName += ".exe";
+            }
+            else if (buildTarget == BuildTarget.Android)
+            {
+#if UNITY_2018_3_OR_NEWER
+                buildName += EditorUserBuildSettings.buildAppBundle ? ".aab" : ".apk";
+#else
+            buildName += ".apk";
+#endif
+            }
+            return buildPath + buildName;
+        }
+
+        static BuildOptions GetBuildOptions()
+        {
+            if (TryGetEnv(BUILD_OPTIONS_ENV_VAR, out string envVar))
+            {
+                string[] allOptionVars = envVar.Split(',');
+                BuildOptions allOptions = BuildOptions.None;
+                BuildOptions option;
+                string optionVar;
+                int length = allOptionVars.Length;
+
+                Console.WriteLine($":: Detecting {BUILD_OPTIONS_ENV_VAR} env var with {length} elements ({envVar})");
+
+                for (int i = 0; i < length; i++)
+                {
+                    optionVar = allOptionVars[i];
+
+                    if (optionVar.TryConvertToEnum(out option))
+                    {
+                        allOptions |= option;
+                    }
+                    else
+                    {
+                        Console.WriteLine($":: Cannot convert {optionVar} to {nameof(BuildOptions)} enum, skipping it.");
+                    }
+                }
+
+                return allOptions;
+            }
+
+            return BuildOptions.None;
+        }
+
+        // https://stackoverflow.com/questions/1082532/how-to-tryparse-for-enum-value
+        static bool TryConvertToEnum<TEnum>(this string strEnumValue, out TEnum value)
+        {
+            if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
+            {
+                value = default;
+                return false;
+            }
+
+            value = (TEnum)Enum.Parse(typeof(TEnum), strEnumValue);
+            return true;
+        }
+
+        internal static bool TryGetEnv(string key, out string value)
+        {
+            value = Environment.GetEnvironmentVariable(key);
+            return !string.IsNullOrEmpty(value);
+        }
+
+        static void SetScriptingBackendFromEnv(BuildTarget platform)
+        {
+            var targetGroup = BuildPipeline.GetBuildTargetGroup(platform);
+            if (TryGetEnv(SCRIPTING_BACKEND_ENV_VAR, out string scriptingBackend))
+            {
+                if (scriptingBackend.TryConvertToEnum(out ScriptingImplementation backend))
+                {
+                    Console.WriteLine($":: Setting ScriptingBackend to {backend}");
+                    PlayerSettings.SetScriptingBackend(targetGroup, backend);
+                }
+                else
+                {
+                    string possibleValues = string.Join(", ", Enum.GetValues(typeof(ScriptingImplementation)).Cast<ScriptingImplementation>());
+                    throw new Exception($"Could not find '{scriptingBackend}' in ScriptingImplementation enum. Possible values are: {possibleValues}");
+                }
+            }
+            else
+            {
+                var defaultBackend = PlayerSettings.GetDefaultScriptingBackend(targetGroup);
+                Console.WriteLine($":: Using project's configured ScriptingBackend (should be {defaultBackend} for targetGroup {targetGroup}");
+            }
+        }
+
+        public static void PerformBuild()
+        {
+            var buildTarget = GetBuildTarget();
+
+            Console.WriteLine(":: Performing build");
+            if (TryGetEnv(VERSION_NUMBER_VAR, out var bundleVersionNumber))
+            {
+                if (buildTarget == BuildTarget.iOS)
+                {
+                    bundleVersionNumber = GetIosVersion();
+                }
+                Console.WriteLine($":: Setting bundleVersionNumber to '{bundleVersionNumber}' (Length: {bundleVersionNumber.Length})");
+                PlayerSettings.bundleVersion = bundleVersionNumber;
+            }
+
+            if (buildTarget == BuildTarget.Android)
+            {
+                HandleAndroidAppBundle();
+                HandleAndroidBundleVersionCode();
+                HandleAndroidKeystore();
+            }
+
+            var buildPath = GetBuildPath();
+            var buildName = GetBuildName();
+            var buildOptions = GetBuildOptions();
+            var fixedBuildPath = GetFixedBuildPath(buildTarget, buildPath, buildName);
+
+            SetScriptingBackendFromEnv(buildTarget);
+
+            var buildReport = BuildPipeline.BuildPlayer(GetEnabledScenes(), fixedBuildPath, buildTarget, buildOptions);
+
+            if (buildReport.summary.result != UnityEditor.Build.Reporting.BuildResult.Succeeded)
+                throw new Exception($"Build ended with {buildReport.summary.result} status");
+
+            Console.WriteLine(":: Done with build");
+        }
+
+        private static void HandleAndroidAppBundle()
+        {
+            if (TryGetEnv(ANDROID_APP_BUNDLE, out string value))
+            {
+#if UNITY_2018_3_OR_NEWER
+                if (bool.TryParse(value, out bool buildAppBundle))
+                {
+                    EditorUserBuildSettings.buildAppBundle = buildAppBundle;
+                    Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected, set buildAppBundle to {value}.");
+                }
+                else
+                {
+                    Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected but the value \"{value}\" is not a boolean.");
+                }
+#else
+            Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected but does not work with lower Unity version than 2018.3");
+#endif
+            }
+        }
+
+        private static void HandleAndroidBundleVersionCode()
+        {
+            if (TryGetEnv(ANDROID_BUNDLE_VERSION_CODE, out string value))
+            {
+                if (int.TryParse(value, out int version))
+                {
+                    PlayerSettings.Android.bundleVersionCode = version;
+                    Console.WriteLine($":: {ANDROID_BUNDLE_VERSION_CODE} env var detected, set the bundle version code to {value}.");
+                }
+                else
+                    Console.WriteLine($":: {ANDROID_BUNDLE_VERSION_CODE} env var detected but the version value \"{value}\" is not an integer.");
+            }
+        }
+
+        private static string GetIosVersion()
+        {
+            if (TryGetEnv(VERSION_iOS, out string value))
+            {
+                if (int.TryParse(value, out int version))
+                {
+                    Console.WriteLine($":: {VERSION_iOS} env var detected, set the version to {value}.");
+                    return version.ToString();
+                }
+                else
+                    Console.WriteLine($":: {VERSION_iOS} env var detected but the version value \"{value}\" is not an integer.");
+            }
+
+            throw new ArgumentNullException(nameof(value), $":: Error finding {VERSION_iOS} env var");
+        }
+
+        private static void HandleAndroidKeystore()
+        {
+#if UNITY_2019_1_OR_NEWER
+            PlayerSettings.Android.useCustomKeystore = false;
+#endif
+
+            if (!File.Exists(KEYSTORE))
+            {
+                Console.WriteLine($":: {KEYSTORE} not found, skipping setup, using Unity's default keystore");
+                return;
+            }
+
+            PlayerSettings.Android.keystoreName = KEYSTORE;
+
+            string keystorePass;
+            string keystoreAliasPass;
+
+            if (TryGetEnv(KEY_ALIAS_NAME, out string keyaliasName))
+            {
+                PlayerSettings.Android.keyaliasName = keyaliasName;
+                Console.WriteLine($":: using ${KEY_ALIAS_NAME} env var on PlayerSettings");
+            }
+            else
+            {
+                Console.WriteLine($":: ${KEY_ALIAS_NAME} env var not set, using Project's PlayerSettings");
+            }
+
+            if (!TryGetEnv(KEYSTORE_PASS, out keystorePass))
+            {
+                Console.WriteLine($":: ${KEYSTORE_PASS} env var not set, skipping setup, using Unity's default keystore");
+                return;
+            }
+
+            if (!TryGetEnv(KEY_ALIAS_PASS, out keystoreAliasPass))
+            {
+                Console.WriteLine($":: ${KEY_ALIAS_PASS} env var not set, skipping setup, using Unity's default keystore");
+                return;
+            }
+#if UNITY_2019_1_OR_NEWER
+            PlayerSettings.Android.useCustomKeystore = true;
+#endif
+            PlayerSettings.Android.keystorePass = keystorePass;
+            PlayerSettings.Android.keyaliasPass = keystoreAliasPass;
+        }
+    }
+    
+    public class GDKPreProcessBuild: IPreprocessBuildWithReport
+    {
+    #if UNITY_2022_1_OR_NEWER
+        private static readonly string GRADLE_VERSION = "7.6.1";
+    #else
+        private static readonly string GRADLE_VERSION = "6.7.1";
+    #endif
+        private static readonly string GRADLE_ROOT = "/usr/local/gradle";
+        
+        public int callbackOrder
+        {
+            get { return 0; }
+        }
+        public void OnPreprocessBuild(BuildReport report)
+        {
+            if (report.summary.platform == BuildTarget.Android)
+            {
+                // Change Gradle path when running in headless mode (CI Machine)
+                if (Application.isBatchMode)
+                {   
+                    EditorPrefs.SetBool("GradleUseEmbedded", false);
+                    
+                    if (GDKCIBuildCommand.TryGetEnv("GRADLE_PATH", out string envGradlePath))
+                    {   
+                        EditorPrefs.SetString("GradlePath", envGradlePath);
+                        Debug.Log("Update gradle path to: " + envGradlePath);
+                    }
+                    else
+                    {
+                        string gradlePath = GRADLE_ROOT + "/gradle-" + GRADLE_VERSION;
+                        EditorPrefs.SetString("GradlePath", gradlePath);
+                        Debug.Log("Update gradle path to: " + gradlePath);
+                    }
+                }
+            }
+            
+        }
+    }
+}

package/Editor/Extra/GDKCIBuildCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bfe10a860d56457f86c6bb3931b972a5
+timeCreated: 1706775850

package/Editor/Extra/GDKLocalBuild.cs

@@ -350,8 +350,8 @@ namespace Amanotes.Editor
                 {
                     PlayerSettings.Android.bundleVersionCode = buildNumber;
                     PlayerSettings.Android.buildApkPerCpuArchitecture = splitAPK;
-                    PlayerSettings.Android.targetArchitectures = AndroidArchitecture.All;
-
+                    PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64 | AndroidArchitecture.ARMv7;
+                    
                     EditorUserBuildSettings.buildAppBundle = isAAB;
                     EditorUserBuildSettings.exportAsGoogleAndroidProject = false;
                     
@@ -817,6 +817,7 @@ namespace Amanotes.Editor
                 {
                     ab.buildRQ = GDKLocalBuild.BuildRequestTS.Generate(); //ab.runGitPostBuild
                     ab.ProcessBuild();
+                    GUIUtility.ExitGUI();
                 }
 
                 if (GUILayout.Button("Stop")) ab.StopBuild();

package/Editor/Extra/GDKProjectCP.cs

@@ -1,3 +1,4 @@
+using Amanotes.Core.Internal;
 using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
@@ -149,10 +150,67 @@ namespace Amanotes
 			if (productNameStyle == null) Init();
 
 			DrawProjectInfo();
+
+			if (EditorApplication.isPlayingOrWillChangePlaymode)
+			{
+				// EditorGUILayout.HelpBox("Application is Playing!", MessageType.Info);
+				DrawRuntimeGUI();
+				return;
+			}
+			
 			EditorGUILayout.Space();
 			DrawBigPlayButton();
 			EditorGUILayout.Space();
 			DrawListScenes();
 		}
+
+
+		private readonly List<float> FPS = new List<float>()
+		{
+			0, 1, 5, 10, 15, 20, 30, 45, 50, 60, 75, 90, 120, 240, 360, 480, 720, 960, 1000, 1200
+		};
+		
+		private readonly List<float> TIMESCALES = new List<float>()
+		{
+			0f, 0.1f, 0.2f, 0.5f, 1f, 2f, 5f, 10f
+		};
+		
+		void DrawRuntimeGUI()
+		{
+			float fps = Application.targetFrameRate;
+			if (DrawSlider2("Target FPS", ref fps, FPS))
+			{
+				Application.targetFrameRate = (int)fps;
+			}
+			
+			float ts = Time.timeScale;
+			if (DrawSlider2("Time Scale", ref ts, TIMESCALES))
+			{
+				Time.timeScale = ts;
+			}
+		}
+		
+		bool DrawSlider2(string label, ref float v, List<float> values)
+		{
+			int idx1 = values.IndexOf(v);
+			if (idx1 == -1)
+			{
+				values.Add(v);
+				values.Sort();
+				idx1 = values.IndexOf(v);
+			}
+
+			int idx2;
+			GUILayout.BeginHorizontal();
+			{
+				GUILayout.Label(label, GUILayout.Width(100f));
+				idx2 = Mathf.RoundToInt(GUILayout.HorizontalSlider(idx1, 0, values.Count - 1));
+				GUILayout.Label($"{v}", GUILayout.Width(50f));
+			}
+			GUILayout.EndHorizontal();
+			if (idx2 == idx1) return false;
+			v = values[idx2];
+			return true;
+		}
 	}
 }

package/Editor/Utils/AmaGDKEditor.ExtractVersion.cs

@@ -5,6 +5,11 @@ using System.Linq;
 using System.Reflection;
 using System.Xml;
 using Amanotes.Core.Internal;
+#if !UNITY_2021_1_OR_NEWER
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEditor.PackageManager.Requests;
+#endif
 using UnityEngine;
 using static Amanotes.Core.AmaGDK.AdapterID;
 
@@ -66,9 +71,38 @@ namespace Amanotes.Editor
             return result;
         }
     }
-
+    
     internal static class ExtractVersion
     {
+#if !UNITY_2021_1_OR_NEWER
+        static ListRequest listRequest;
+        const string LIST_REQUEST_KEY = "ListRequestData";
+        
+        [InitializeOnLoadMethod]
+        static void Initialize()
+        {
+            Events.registeredPackages += RegisteredPackages;
+            GetRequestList();
+        }
+
+        private static void RegisteredPackages(PackageRegistrationEventArgs obj)
+        {
+            PlayerPrefs.DeleteKey(LIST_REQUEST_KEY);
+            GetRequestList();
+        }
+
+        static void GetRequestList()
+        {
+            if (PlayerPrefs.HasKey(LIST_REQUEST_KEY))
+            {
+                listRequest = JsonUtility.FromJson<ListRequest>(PlayerPrefs.GetString(LIST_REQUEST_KEY));
+                return;
+            }
+            
+            listRequest = Client.List();
+        }
+#endif
+
         public static string GDKAdapter(string sdkId)
         {
             var version = "";
@@ -94,20 +128,54 @@ namespace Amanotes.Editor
             }
             return version.Trim();
         }
+        
+        static string GetPackageVersion(string packageName)
+        {
+#if UNITY_2021_1_OR_NEWER
+            foreach (var package in UnityEditor.PackageManager.PackageInfo.GetAllRegisteredPackages())
+            {
+                if(package.name != packageName) continue;
+                return package.version;
+            }
+            
+#else
+            if (listRequest == null || !listRequest.IsCompleted) return "";
+            
+            if (listRequest.Status != StatusCode.Success)
+            {
+                Debug.LogWarning($"Failed to list packages: {listRequest.Error.message}");
+                return "";
+            }
+
+            if (!PlayerPrefs.HasKey(LIST_REQUEST_KEY))
+            {
+                PlayerPrefs.SetString(LIST_REQUEST_KEY, JsonUtility.ToJson(listRequest));
+                PlayerPrefs.Save();
+            }
+
+            foreach (var package in listRequest.Result)
+            {
+                if(package.name != packageName) continue;
+                
+                return package.version;
+            }
+#endif
+            return "";
+        }
 
         public static string ThirdParty(string sdkId)
         {
             var version = "";
             switch (sdkId)
             {
-            case FIREBASE_ANALYTICS: return FirebaseAnalytics();
-            case FIREBASE_REMOTE_CONFIG: return FirebaseRemoteConfig();
-            case APPSFLYER: return AppsFlyer();
-            case IRONSOURCE: return Ironsource();
-            case REVENUECAT: return RevenueCat();
-            default:
-                Debug.LogWarning($"Unsupported sdkID <{sdkId}>");
-                break;
+                case FIREBASE_ANALYTICS: return FirebaseAnalytics();
+                case FIREBASE_REMOTE_CONFIG: return FirebaseRemoteConfig();
+                case APPSFLYER: return AppsFlyer();
+                case IRONSOURCE: return Ironsource();
+                case REVENUECAT: return RevenueCat();
+                default:
+                    Debug.LogWarning($"Unsupported sdkID <{sdkId}>");
+                    break;
             }
             return version;
         }
@@ -116,7 +184,7 @@ namespace Amanotes.Editor
         {
             var version = "";
             string[] filesFirebase = Directory.GetFiles("Assets", "maven-metadata.xml", SearchOption.AllDirectories);
-            if (filesFirebase.Length <= 0) return version.Trim();
+            if (filesFirebase.Length <= 0) return GetPackageVersion("com.google.firebase.analytics").Trim();
 
             for (var i = 0; i < filesFirebase.Length; i++)
             {
@@ -140,7 +208,7 @@ namespace Amanotes.Editor
         {
             var version = "";
             string[] filesFirebase = Directory.GetFiles("Assets", "maven-metadata.xml", SearchOption.AllDirectories);
-            if (filesFirebase.Length <= 0) return version.Trim();
+            if (filesFirebase.Length <= 0) return GetPackageVersion("com.google.firebase.remote-config").Trim();
 
             for (var i = 0; i < filesFirebase.Length; i++)
             {
@@ -190,7 +258,6 @@ namespace Amanotes.Editor
                     }
                 }
             }
-
             return version.Trim();
         }
 
@@ -213,10 +280,7 @@ namespace Amanotes.Editor
             string[] files = Directory.GetFiles("Assets", "PurchasesWrapper.java", SearchOption.AllDirectories);
             var searchString = "PLUGIN_VERSION";
             var version = "";
-            if (files.Length < 1)
-            {
-                return version;
-            }
+            if (files.Length < 1) return GetPackageVersion("com.revenuecat.purchases-unity").Trim();
 
             foreach (string file in files)
             {
@@ -236,9 +300,16 @@ namespace Amanotes.Editor
 
         internal static List<IronSourceSDKAdapter> IronSourceAdapter()
         {
-            string[] filesIRadapter = Directory.GetFiles("Assets/IronSource", "IS*AdapterDependencies.xml", SearchOption.AllDirectories);
-            List<IronSourceSDKAdapter> listAdapter = new List<IronSourceSDKAdapter>();
-
+            var listAdapter = new List<IronSourceSDKAdapter>();
+            const string IRONSOURCE_PATH = "Assets/IronSource";
+            
+            if (!Directory.Exists(IRONSOURCE_PATH))
+            {
+                return listAdapter;
+            }
+            
+            string[] filesIRadapter = Directory.GetFiles(IRONSOURCE_PATH, "IS*AdapterDependencies.xml", SearchOption.AllDirectories);
+            
             if (filesIRadapter.Length <= 0) return listAdapter;
             for (var i = 0; i < filesIRadapter.Length; i++)
             {