com.amanotes.gdk 0.2.87 → 0.2.89

package/CHANGELOG.md

@@ -1,3 +1,44 @@
+## [0.2.89] - 2025-08-05
+- [Fix] Null Exception when ad load failed
+- [Fix] Don't cancel unity build jobs
+- [Fix] Build Unity 2021
+- [Dev] Remove Ad Quality
+- [Dev] Fix build jobs
+- [Dev] Upgrade unity version
+- [Dev] Add retrier for unity license
+- [Dev] Remove gradle path on CI
+- [Dev] Update integration test
+- [Dev] Improve build command
+- [Dev] Update project settings
+- [Dev] Return unity license
+- [Dev] Upgrade Ironsource v8.10.0 & Max v13.3.1
+- [Dev] Migrate CI to TartVM workflow
+- [Dev] Upgrade unity versions
+
+## [0.2.88] - 2025-07-05
+- [Dev] Various fixes for Unity 6
+- [Fix] Update marker block id for Notion change log
+- [Dev] Add AI config
+- [Dev] Improve crap score 2
+- [Dev] Reduce complexity & crap score
+- [Dev] Various warning fixes & Improve message verification in tests
+- [Fix] Compiler error in Unity 2023+
+- [Dev] Track max adapters
+- [Fix] Do not override config when Adapter id is not available
+- [Fix] Bypass file utils unit test
+- [Dev] Improve verbose logging
+- [BugFix]: Fix sentry issue : Null exception issue
+- [Fix] Missing User Mapping in MaxAdapter
+- [Fix] Manage ad activity killed routine
+- [Fix] Attach JNI thread
+- [Fix] Missing DoOnMainThread for ConsentInformation update
+- [Fix] Send GDKVersionTracking only for Android/iOS
+- [Dev] Rename Remote Config Data Source
+- [Fix] Improve disk space checking with thead pool
+- [Dev] Refactor DiskSpacePopup
+- [Fix] Add missing scope registry for integration test
+- [Dev] Add UniTask Dependency
+
 ## [0.2.87] - 2025-06-19
 - [Dev] Add AI config
 - [Dev] Improve crap score 2

package/Editor/AmaGDKEditor.cs

@@ -245,8 +245,10 @@ namespace Amanotes.Editor
             bannerTitle ??= new GUIContent()
             {
                 image = logo.Value,
-                text = $"<b>AmaGDK</b> <size=12><color=gray>v{AmaGDK.VERSION}</color></size>"
+                text = $"<b>AmaGDK</b> <size=12><color=\"grey\">v{AmaGDK.VERSION}</color></size>"
             };
+            
+            
             AmaGUI.SectionLabel(bannerTitle);
             var rect = GUILayoutUtility.GetLastRect();
             var btnRect = rect;

package/Editor/Extra/GDKCIBuildCommand.cs

@@ -10,12 +10,18 @@ using Debug = UnityEngine.Debug;
 
 namespace Amanotes.Core
 {
+    /// <summary>
+    /// Unity CI Build Command for GitLab CI integration.
+    /// Supports Unity 2021+ with backward compatibility for current features.
+    /// </summary>
     public static class GDKCIBuildCommand
     {
+        #region Constants
+        
+        // Environment variable keys
         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_APP_BUNDLE = "BUILD_APP_BUNDLE";
         private const string SCRIPTING_BACKEND_ENV_VAR = "SCRIPTING_BACKEND";
@@ -23,418 +29,701 @@ namespace Amanotes.Core
         private const string VERSION_NUMBER_VAR = "VERSION_NUMBER_VAR";
         private const string VERSION_BUILD_VAR = "VERSION_BUILD_VAR";
         
+        // File paths
+        private const string KEYSTORE = "keystore.keystore";
+        
+        // Other constants
+        private static readonly string Eol = Environment.NewLine;
+        
+        #endregion
+
+        #region Pod Installation
+        
+        /// <summary>
+        /// Installs CocoaPods for iOS builds.
+        /// </summary>
+        /// <param name="processExit">Event handler for process completion</param>
+        /// <param name="buildPath">Build path for pod installation</param>
         public static void InstallPod(EventHandler processExit, string buildPath = null)
         {
             try
             {
-                string arguments = "";
-                if (Application.isBatchMode && TryGetEnv("CI_SCRIPT_DIR", out string scriptDir))
-                {
-                    arguments = $"{scriptDir}/utils.sh pod-install";
-                }
-                else if (!Application.isBatchMode)
-                {
-                    string podPath = "/usr/local/bin/pod";
-                    if (!File.Exists(podPath)) podPath = "/opt/homebrew/bin/pod";
-                    arguments = $"-c \"{podPath} install --project-directory={buildPath}\"";
-                }
+                LogInfo("Starting CocoaPods installation...");
                 
-                // Configure process start info
-                var startInfo = new ProcessStartInfo
-                {
-                    FileName = "/bin/zsh",
-                    Arguments = arguments,
-                    CreateNoWindow = false,
-                    RedirectStandardOutput = true,
-                    RedirectStandardError = true,
-                    UseShellExecute = false
-                };
-
-                var proc = new Process
+                string arguments = GetPodInstallArguments(buildPath);
+                if (string.IsNullOrEmpty(arguments))
                 {
-                    StartInfo = startInfo,
-                    EnableRaisingEvents = true
-                };
-
-                // Attach event handlers
-                proc.OutputDataReceived += (sender, args) =>
-                {
-                    if (args.Data == null) return; // End of the stream
-                    Debug.Log(args.Data);
-                };
-
-                proc.Exited += processExit;
+                    LogWarning("No pod install arguments configured. Skipping pod installation.");
+                    return;
+                }
 
-                // Start the process
-                proc.Start();
-                proc.BeginOutputReadLine();
-                proc.BeginErrorReadLine();
-                proc.WaitForExit();
+                var process = CreatePodInstallProcess(arguments, processExit);
+                ExecuteProcess(process);
             }
             catch (Exception e)
             {
+                LogError($"Pod installation failed: {e.Message}");
                 Debug.LogError(e);
             }
         }
 
-        static string GetArgument(string name)
+        private static string GetPodInstallArguments(string buildPath)
         {
-            string[] args = Environment.GetCommandLineArgs();
-            for (int i = 0; i < args.Length; i++)
+            if (Application.isBatchMode && TryGetEnv("CI_SCRIPT_DIR", out string scriptDir))
             {
-                if (args[i].Contains(name))
+                return $"{scriptDir}/utils.sh pod-install";
+            }
+            
+            if (!Application.isBatchMode && !string.IsNullOrEmpty(buildPath))
+            {
+                string podPath = GetPodExecutablePath();
+                if (!string.IsNullOrEmpty(podPath))
                 {
-                    return args[i + 1];
+                    return $"-c \"{podPath} install --project-directory={buildPath}\"";
                 }
             }
+            
             return null;
         }
 
-        static string[] GetEnabledScenes()
+        private static string GetPodExecutablePath()
         {
-            return (
-                from scene in EditorBuildSettings.scenes
-                where scene.enabled
-                where !string.IsNullOrEmpty(scene.path)
-                select scene.path
-            ).ToArray();
+            string[] possiblePaths = { "/usr/local/bin/pod", "/opt/homebrew/bin/pod" };
+            return possiblePaths.FirstOrDefault(File.Exists);
         }
 
-        static BuildTarget GetBuildTarget()
+        private static Process CreatePodInstallProcess(string arguments, EventHandler processExit)
         {
-            string buildTargetName = GetArgument("customBuildTarget");
-            Console.WriteLine(":: Received customBuildTarget " + buildTargetName);
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = "/bin/zsh",
+                Arguments = arguments,
+                CreateNoWindow = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false
+            };
 
-            if (buildTargetName.ToLower() == "android")
+            var process = new Process
             {
-#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
-            }
+                StartInfo = startInfo,
+                EnableRaisingEvents = true
+            };
 
-            if (buildTargetName.TryConvertToEnum(out BuildTarget target))
-                return target;
+            process.OutputDataReceived += (sender, args) =>
+            {
+                if (args.Data != null)
+                {
+                    Debug.Log(args.Data);
+                }
+            };
 
-            Console.WriteLine($":: {nameof(buildTargetName)} \"{buildTargetName}\" not defined on enum {nameof(BuildTarget)}, using {nameof(BuildTarget.NoTarget)} enum to build");
+            process.Exited += processExit;
+            return process;
+        }
 
-            return BuildTarget.NoTarget;
+        private static void ExecuteProcess(Process process)
+        {
+            process.Start();
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+            process.WaitForExit();
         }
+        
+        #endregion
 
-        static string GetBuildPath()
+        #region Argument Parsing
+        
+        /// <summary>
+        /// Gets a command line argument value by name.
+        /// </summary>
+        /// <param name="name">Argument name to search for</param>
+        /// <returns>Argument value or null if not found</returns>
+        private static string GetArgument(string name)
+        {
+            string[] args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i].Contains(name) && i + 1 < args.Length)
+                {
+                    return args[i + 1];
+                }
+            }
+            return null;
+        }
+
+        private static string GetBuildPath()
         {
             string buildPath = GetArgument("customBuildPath");
-            Console.WriteLine(":: Received customBuildPath " + buildPath);
-            if (buildPath == "")
+            LogInfo($"Received customBuildPath: {buildPath}");
+            
+            if (string.IsNullOrEmpty(buildPath))
             {
-                throw new Exception("customBuildPath argument is missing");
+                throw new ArgumentException("customBuildPath argument is missing");
             }
+            
             return buildPath;
         }
 
-        static string GetBuildName()
+        private static string GetBuildName()
         {
             string buildName = GetArgument("customBuildName");
-            Console.WriteLine(":: Received customBuildName " + buildName);
-            if (buildName == "")
+            LogInfo($"Received customBuildName: {buildName}");
+            
+            if (string.IsNullOrEmpty(buildName))
             {
-                throw new Exception("customBuildName argument is missing");
+                throw new ArgumentException("customBuildName argument is missing");
             }
+            
             return buildName;
         }
+        
+        #endregion
+
+        #region Build Configuration
+        
+        /// <summary>
+        /// Gets enabled scenes for build.
+        /// </summary>
+        /// <returns>Array of enabled scene paths</returns>
+        private static string[] GetEnabledScenes()
+        {
+            return EditorBuildSettings.scenes
+                .Where(scene => scene.enabled && !string.IsNullOrEmpty(scene.path))
+                .Select(scene => scene.path)
+                .ToArray();
+        }
 
-        static string GetFixedBuildPath(BuildTarget buildTarget, string buildPath, string buildName)
+        /// <summary>
+        /// Determines build target from command line arguments.
+        /// </summary>
+        /// <returns>Build target enum value</returns>
+        private static BuildTarget GetBuildTarget()
         {
-            if (buildTarget.ToString().ToLower().Contains("windows"))
+            string buildTargetName = GetArgument("customBuildTarget");
+            LogInfo($"Received customBuildTarget: {buildTargetName}");
+
+            if (string.IsNullOrEmpty(buildTargetName))
             {
-                buildName += ".exe";
+                throw new ArgumentException("customBuildTarget argument is missing");
             }
-            else if (buildTarget == BuildTarget.Android)
+
+            // Handle legacy Android build system for very old Unity versions
+            if (buildTargetName.ToLower() == "android")
             {
-#if UNITY_2018_3_OR_NEWER
-                buildName += EditorUserBuildSettings.buildAppBundle ? ".aab" : ".apk";
-#else
-            buildName += ".apk";
+#if !UNITY_5_6_OR_NEWER
+                // Legacy compatibility for Unity < 5.6
+                EditorUserBuildSettings.androidBuildSystem = AndroidBuildSystem.Internal;
 #endif
             }
-            return buildPath + buildName;
-        }
 
-        static BuildOptions GetBuildOptions()
-        {
-            if (TryGetEnv(BUILD_OPTIONS_ENV_VAR, out string envVar))
+            if (buildTargetName.TryConvertToEnum(out BuildTarget target))
             {
-                string[] allOptionVars = envVar.Split(',');
-                BuildOptions allOptions = BuildOptions.None;
-                BuildOptions option;
-                string optionVar;
-                int length = allOptionVars.Length;
+                return target;
+            }
 
-                Console.WriteLine($":: Detecting {BUILD_OPTIONS_ENV_VAR} env var with {length} elements ({envVar})");
+            LogWarning($"Build target '{buildTargetName}' not recognized. Available targets: {string.Join(", ", Enum.GetNames(typeof(BuildTarget)))}");
+            return BuildTarget.NoTarget;
+        }
 
-                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.");
-                    }
-                }
+        /// <summary>
+        /// Generates the final build path with appropriate file extension.
+        /// </summary>
+        private static string GetFixedBuildPath(BuildTarget buildTarget, string buildPath, string buildName)
+        {
+            string extension = GetBuildExtension(buildTarget);
+            return Path.Combine(buildPath, buildName + extension);
+        }
 
-                return allOptions;
+        private static string GetBuildExtension(BuildTarget buildTarget)
+        {
+            switch (buildTarget)
+            {
+                case BuildTarget.StandaloneWindows:
+                case BuildTarget.StandaloneWindows64:
+                    return ".exe";
+                    
+                case BuildTarget.Android:
+#if UNITY_2018_3_OR_NEWER
+                    return EditorUserBuildSettings.buildAppBundle ? ".aab" : ".apk";
+#else
+                    return ".apk";
+#endif
+                    
+                default:
+                    return string.Empty;
             }
-
-            return BuildOptions.None;
         }
 
-        // https://stackoverflow.com/questions/1082532/how-to-tryparse-for-enum-value
-        static bool TryConvertToEnum<TEnum>(this string strEnumValue, out TEnum value)
+        /// <summary>
+        /// Parses build options from environment variables.
+        /// </summary>
+        /// <returns>Combined build options</returns>
+        private static BuildOptions GetBuildOptions()
         {
-            if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
+            if (!TryGetEnv(BUILD_OPTIONS_ENV_VAR, out string envVar))
             {
-                value = default;
-                return false;
+                return BuildOptions.None;
             }
 
-            value = (TEnum)Enum.Parse(typeof(TEnum), strEnumValue);
-            return true;
-        }
+            string[] optionNames = envVar.Split(',');
+            BuildOptions combinedOptions = BuildOptions.None;
 
-        internal static bool TryGetEnv(string key, out string value)
-        {
-            value = Environment.GetEnvironmentVariable(key);
-            return !string.IsNullOrEmpty(value);
+            LogInfo($"Parsing {BUILD_OPTIONS_ENV_VAR} with {optionNames.Length} options: {envVar}");
+
+            foreach (string optionName in optionNames)
+            {
+                if (optionName.TryConvertToEnum(out BuildOptions option))
+                {
+                    combinedOptions |= option;
+                }
+                else
+                {
+                    LogWarning($"Unknown build option: '{optionName}'. Skipping.");
+                }
+            }
+
+            return combinedOptions;
         }
+        
+        #endregion
 
-        static void SetScriptingBackendFromEnv(BuildTarget platform)
+        #region Unity Version Compatibility
+        
+        /// <summary>
+        /// Sets scripting backend based on environment variable.
+        /// Handles Unity version differences for API compatibility.
+        /// </summary>
+        private 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}");
-                    #if UNITY_2023_2_OR_NEWER
-                    PlayerSettings.SetScriptingBackend(UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(targetGroup), backend);
-                    #else
-                    PlayerSettings.SetScriptingBackend(targetGroup, backend);
-                    #endif
+                    LogInfo($"Setting ScriptingBackend to {backend}");
+                    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}");
+                    var availableBackends = string.Join(", ", Enum.GetValues(typeof(ScriptingImplementation)).Cast<ScriptingImplementation>());
+                    throw new ArgumentException($"Invalid scripting backend '{scriptingBackend}'. Available options: {availableBackends}");
                 }
             }
             else
             {
-                #if UNITY_2023_2_OR_NEWER
-                var defaultBackend = PlayerSettings.GetDefaultScriptingBackend(UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(targetGroup));
-                #else
-                var defaultBackend = PlayerSettings.GetDefaultScriptingBackend(targetGroup);
-                #endif
-                Console.WriteLine($":: Using project's configured ScriptingBackend (should be {defaultBackend} for targetGroup {targetGroup}");
+                var defaultBackend = GetDefaultScriptingBackend(targetGroup);
+                LogInfo($"Using project's default ScriptingBackend: {defaultBackend} for {targetGroup}");
             }
         }
 
-        public static void PerformBuild()
+        private static void SetScriptingBackend(BuildTargetGroup targetGroup, ScriptingImplementation backend)
         {
-            var buildTarget = GetBuildTarget();
-
-            Console.WriteLine(":: Performing build");
-            if (TryGetEnv(VERSION_NUMBER_VAR, out string bundleVersionNumber))
-            {
-                Console.WriteLine($":: Setting bundleVersionNumber to '{bundleVersionNumber}' (Length: {bundleVersionNumber.Length})");
-                PlayerSettings.bundleVersion = bundleVersionNumber;
-            }
-            HandleBuildNumber(buildTarget);
-
-            if (buildTarget == BuildTarget.Android)
-            {
-                HandleAndroidAppBundle();
-                HandleAndroidKeystore();
-                HandleDebugSymbols();
-                HandleExportAndroidProject();
-            }
-
-            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");
-
-            BuildMetadata.Save(buildPath, buildTarget);
-            Console.WriteLine(":: Done with build");
+#if UNITY_2023_2_OR_NEWER
+            PlayerSettings.SetScriptingBackend(UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(targetGroup), backend);
+#else
+            PlayerSettings.SetScriptingBackend(targetGroup, backend);
+#endif
         }
 
-        private static void HandleAndroidAppBundle()
+        private static ScriptingImplementation GetDefaultScriptingBackend(BuildTargetGroup targetGroup)
         {
-            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.");
-                }
+#if UNITY_2023_2_OR_NEWER
+            return PlayerSettings.GetDefaultScriptingBackend(UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(targetGroup));
 #else
-            Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected but does not work with lower Unity version than 2018.3");
+            return PlayerSettings.GetDefaultScriptingBackend(targetGroup);
 #endif
-            }
         }
+        
+        #endregion
 
-        private static void HandleBuildNumber(BuildTarget buildTarget)
+        #region Android-Specific Handling
+        
+        private static void HandleAndroidConfiguration(BuildTarget buildTarget)
         {
-            if (!TryGetEnv(VERSION_BUILD_VAR, out string value)) return;
-            if (int.TryParse(value, out int version))
+            if (buildTarget != BuildTarget.Android) return;
+            
+            LogInfo("Configuring Android-specific settings...");
+            HandleAndroidAppBundle();
+            HandleAndroidKeystore();
+            HandleDebugSymbols();
+            HandleExportAndroidProject();
+        }
+
+        private static void HandleAndroidAppBundle()
+        {
+            if (!TryGetEnv(ANDROID_APP_BUNDLE, out string value)) return;
+
+#if UNITY_2018_3_OR_NEWER
+            if (bool.TryParse(value, out bool buildAppBundle))
             {
-                if (buildTarget == BuildTarget.Android)
-                {
-                    PlayerSettings.Android.bundleVersionCode = version;    
-                }
-                else if (buildTarget == BuildTarget.iOS)
-                {
-                    PlayerSettings.iOS.buildNumber = version.ToString();
-                }
-                    
-                Console.WriteLine($":: {VERSION_BUILD_VAR} env var detected, set the bundle version code to {value}.");
+                EditorUserBuildSettings.buildAppBundle = buildAppBundle;
+                LogInfo($"Set buildAppBundle to {buildAppBundle}");
             }
             else
-                Console.WriteLine($":: {VERSION_BUILD_VAR} env var detected but the version value \"{value}\" is not an integer.");
+            {
+                LogWarning($"Invalid {ANDROID_APP_BUNDLE} value: '{value}'. Expected boolean.");
+            }
+#else
+            LogWarning($"{ANDROID_APP_BUNDLE} requires Unity 2018.3 or newer. Current version does not support this feature.");
+#endif
         }
 
         private static void HandleExportAndroidProject()
         {
             EditorUserBuildSettings.exportAsGoogleAndroidProject = false;
+            
             if (!TryGetEnv(EXPORT_ANDROID_PROJECT, out string stringValue)) return;
+            
             if (bool.TryParse(stringValue, out bool exportAndroidProject))
             {
                 EditorUserBuildSettings.exportAsGoogleAndroidProject = exportAndroidProject;
+                LogInfo($"Set exportAsGoogleAndroidProject to {exportAndroidProject}");
+            }
+            else
+            {
+                LogWarning($"Invalid {EXPORT_ANDROID_PROJECT} value: '{stringValue}'. Expected boolean.");
             }
         }
 
         private static void HandleAndroidKeystore()
         {
+            LogInfo("Configuring Android keystore...");
+
 #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");
+                LogInfo($"Keystore file '{KEYSTORE}' not found. Using Unity's default keystore.");
                 return;
             }
 
             PlayerSettings.Android.keystoreName = KEYSTORE;
+            LogInfo($"Using keystore: {KEYSTORE}");
 
-            string keystorePass;
-            string keystoreAliasPass;
+            ConfigureKeystoreAlias();
+            ConfigureKeystorePasswords();
+        }
 
+        private static void ConfigureKeystoreAlias()
+        {
             if (TryGetEnv(KEY_ALIAS_NAME, out string keyaliasName))
             {
                 PlayerSettings.Android.keyaliasName = keyaliasName;
-                Console.WriteLine($":: using ${KEY_ALIAS_NAME} env var on PlayerSettings");
+                LogInfo($"Set key alias name from environment variable");
             }
             else
             {
-                Console.WriteLine($":: ${KEY_ALIAS_NAME} env var not set, using Project's PlayerSettings");
+                LogInfo($"Using project's default key alias name");
             }
+        }
 
-            if (!TryGetEnv(KEYSTORE_PASS, out keystorePass))
+        private static void ConfigureKeystorePasswords()
+        {
+            if (!TryGetEnv(KEYSTORE_PASS, out string keystorePass))
             {
-                Console.WriteLine($":: ${KEYSTORE_PASS} env var not set, skipping setup, using Unity's default keystore");
+                LogWarning($"{KEYSTORE_PASS} not set. Using Unity's default keystore.");
                 return;
             }
 
-            if (!TryGetEnv(KEY_ALIAS_PASS, out keystoreAliasPass))
+            if (!TryGetEnv(KEY_ALIAS_PASS, out string keystoreAliasPass))
             {
-                Console.WriteLine($":: ${KEY_ALIAS_PASS} env var not set, skipping setup, using Unity's default keystore");
+                LogWarning($"{KEY_ALIAS_PASS} not set. Using Unity's default keystore.");
                 return;
             }
+
 #if UNITY_2019_1_OR_NEWER
             PlayerSettings.Android.useCustomKeystore = true;
 #endif
-            
-            #if UNITY_2023_2_OR_NEWER
+
+#if UNITY_2023_2_OR_NEWER
             PlayerSettings.Android.keystorePass = keystorePass;
-            #else
+#else
             PlayerSettings.keystorePass = keystorePass;
-            #endif
+#endif
             
             PlayerSettings.Android.keyaliasPass = keystoreAliasPass;
+            LogInfo("Keystore passwords configured successfully");
         }
         
         private static void HandleDebugSymbols()
         {
-            #if UNITY_6000_0_OR_NEWER
+            LogInfo("Configuring Android debug symbols...");
+            
+#if UNITY_6000_0_OR_NEWER
             UnityEditor.Android.UserBuildSettings.DebugSymbols.level = Unity.Android.Types.DebugSymbolLevel.SymbolTable;
-            #elif UNITY_2021_1_OR_NEWER
+            LogInfo("Set debug symbols level to SymbolTable (Unity 6+)");
+#elif UNITY_2021_1_OR_NEWER
             EditorUserBuildSettings.androidCreateSymbols = AndroidCreateSymbols.Debugging;
-            #else
-            // For Unity 2020.3 and earlier, use the legacy boolean property
+            LogInfo("Set debug symbols to Debugging (Unity 2021.1+)");
+#else
             EditorUserBuildSettings.androidCreateSymbolsZip = true;
-            #endif
+            LogInfo("Enabled debug symbols zip (Unity 2020.3 and earlier)");
+#endif
+        }
+        
+        #endregion
+
+        #region Version Handling
+        
+        private static void HandleVersionConfiguration(BuildTarget buildTarget)
+        {
+            HandleBundleVersion();
+            HandleBuildNumber(buildTarget);
+        }
+
+        private static void HandleBundleVersion()
+        {
+            if (TryGetEnv(VERSION_NUMBER_VAR, out string bundleVersionNumber))
+            {
+                LogInfo($"Setting bundle version to '{bundleVersionNumber}' (Length: {bundleVersionNumber.Length})");
+                PlayerSettings.bundleVersion = bundleVersionNumber;
+            }
+        }
+
+        private static void HandleBuildNumber(BuildTarget buildTarget)
+        {
+            if (!TryGetEnv(VERSION_BUILD_VAR, out string value)) return;
+            
+            if (!int.TryParse(value, out int buildNumber))
+            {
+                LogWarning($"Invalid {VERSION_BUILD_VAR} value: '{value}'. Expected integer.");
+                return;
+            }
+
+            switch (buildTarget)
+            {
+                case BuildTarget.Android:
+                    PlayerSettings.Android.bundleVersionCode = buildNumber;
+                    LogInfo($"Set Android bundle version code to {buildNumber}");
+                    break;
+                    
+                case BuildTarget.iOS:
+                    PlayerSettings.iOS.buildNumber = buildNumber.ToString();
+                    LogInfo($"Set iOS build number to {buildNumber}");
+                    break;
+                    
+                default:
+                    LogInfo($"Build number not applicable for platform: {buildTarget}");
+                    break;
+            }
+        }
+        
+        #endregion
+
+        #region Main Build Method
+        
+        /// <summary>
+        /// Main entry point for performing Unity builds in CI environment.
+        /// </summary>
+        public static void PerformBuild()
+        {
+            try
+            {
+                LogInfo("=== Starting Unity Build Process ===");
+                
+                var buildTarget = GetBuildTarget();
+                var buildPath = GetBuildPath();
+                var buildName = GetBuildName();
+                var buildOptions = GetBuildOptions();
+                var fixedBuildPath = GetFixedBuildPath(buildTarget, buildPath, buildName);
+
+                LogInfo($"Build configuration: Target={buildTarget}, Path={fixedBuildPath}, Options={buildOptions}");
+
+                // Configure build settings
+                HandleVersionConfiguration(buildTarget);
+                HandleAndroidConfiguration(buildTarget);
+                SetScriptingBackendFromEnv(buildTarget);
+
+                // Perform the build
+                var buildPlayerOptions = new BuildPlayerOptions
+                {
+                    scenes = GetEnabledScenes(),
+                    locationPathName = fixedBuildPath,
+                    target = buildTarget,
+                    targetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget),
+                    options = buildOptions
+                };
+                
+                LogInfo($"Building to: {fixedBuildPath}");
+                var buildReport = BuildPipeline.BuildPlayer(buildPlayerOptions);
+                
+                // Handle build results
+                ReportSummary(buildReport.summary);
+                
+                if (buildReport.summary.result != UnityEditor.Build.Reporting.BuildResult.Succeeded)
+                {
+                    throw new Exception($"Build failed with status: {buildReport.summary.result}");
+                }
+
+                // Save build metadata
+                BuildMetadata.Save(buildPath, buildTarget);
+                LogInfo("=== Build Process Completed Successfully ===");
+            }
+            catch (Exception ex)
+            {
+                LogError($"Build process failed: {ex.Message}");
+                throw;
+            }
+        }
+        
+        #endregion
+
+        #region Build Reporting
+        
+        private static void ReportSummary(BuildSummary summary)
+        {
+            var report = new System.Text.StringBuilder()
+                .AppendLine()
+                .AppendLine("###########################")
+                .AppendLine("#      Build Results      #")
+                .AppendLine("###########################")
+                .AppendLine()
+                .AppendLine($"Platform Group: {summary.platformGroup}")
+                .AppendLine($"Platform: {summary.platform}")
+                .AppendLine($"Result: {summary.result}")
+                .AppendLine($"Duration: {summary.totalTime}")
+                .AppendLine($"Warnings: {summary.totalWarnings}")
+                .AppendLine($"Errors: {summary.totalErrors}")
+                .AppendLine($"Size: {summary.totalSize:N0} bytes")
+                .AppendLine()
+                .ToString();
+
+            Console.WriteLine(report);
+        }
+        
+        #endregion
+
+        #region Utility Methods
+        
+        /// <summary>
+        /// Tries to get environment variable value.
+        /// </summary>
+        /// <param name="key">Environment variable key</param>
+        /// <param name="value">Retrieved value</param>
+        /// <returns>True if variable exists and is not empty</returns>
+        internal static bool TryGetEnv(string key, out string value)
+        {
+            value = Environment.GetEnvironmentVariable(key);
+            return !string.IsNullOrEmpty(value);
+        }
+
+        /// <summary>
+        /// Extension method to safely convert string to enum.
+        /// </summary>
+        private static bool TryConvertToEnum<TEnum>(this string strEnumValue, out TEnum value) where TEnum : struct
+        {
+            return Enum.TryParse(strEnumValue, out value) && Enum.IsDefined(typeof(TEnum), value);
+        }
+
+        private static void LogInfo(string message)
+        {
+            Console.WriteLine($":: {message}");
+        }
+
+        private static void LogWarning(string message)
+        {
+            Console.WriteLine($":: WARNING: {message}");
         }
+
+        private static void LogError(string message)
+        {
+            Console.WriteLine($":: ERROR: {message}");
+        }
+        
+        #endregion
     }
     
+    #region Build Metadata
+    
+    /// <summary>
+    /// Contains build metadata information for CI tracking.
+    /// </summary>
     [Serializable]
     public class BuildMetadata
     {
         public string appVersion;
         public string buildNumber;
-        public string buildTarget; 
+        public string buildTarget;
         
+        /// <summary>
+        /// Saves build metadata to a JSON file in the build directory.
+        /// </summary>
+        /// <param name="buildPath">Build output directory</param>
+        /// <param name="buildTarget">Target platform</param>
         public static void Save(string buildPath, BuildTarget buildTarget)
         {
-            string outputFile = Path.Combine(buildPath, "build_info.json");
-
-            var metadata = new BuildMetadata
+            try
             {
-                appVersion = PlayerSettings.bundleVersion,
-                buildNumber = buildTarget == BuildTarget.Android ? PlayerSettings.Android.bundleVersionCode.ToString() : PlayerSettings.iOS.buildNumber,
-                buildTarget = buildTarget.ToString()
-            };
+                string outputFile = Path.Combine(buildPath, "build_info.json");
 
-            string json = JsonUtility.ToJson(metadata, prettyPrint: true);
-            File.WriteAllText(outputFile, json);
+                var metadata = new BuildMetadata
+                {
+                    appVersion = PlayerSettings.bundleVersion,
+                    buildNumber = GetBuildNumberForPlatform(buildTarget),
+                    buildTarget = buildTarget.ToString()
+                };
+
+                string json = JsonUtility.ToJson(metadata, prettyPrint: true);
+                File.WriteAllText(outputFile, json);
 
-            Console.WriteLine($":: Build information saved to {outputFile}");
+                Console.WriteLine($":: Build metadata saved to: {outputFile}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($":: WARNING: Failed to save build metadata: {ex.Message}");
+            }
+        }
+
+        private static string GetBuildNumberForPlatform(BuildTarget buildTarget)
+        {
+            switch (buildTarget)
+            {
+                case BuildTarget.Android:
+                    return PlayerSettings.Android.bundleVersionCode.ToString();
+                case BuildTarget.iOS:
+                    return PlayerSettings.iOS.buildNumber;
+                default:
+                    return "0";
+            }
         }
     }
     
-    public class GDKPreProcessBuild: IPreprocessBuildWithReport
+    #endregion
+
+    #region Preprocessor
+    
+    /// <summary>
+    /// Preprocessor for handling CI-specific build settings.
+    /// </summary>
+    public class GDKPreProcessBuild : IPreprocessBuildWithReport
     {
-        public int callbackOrder
-        {
-            get { return 0; }
-        }
+        public int callbackOrder => 0;
+
         public void OnPreprocessBuild(BuildReport report)
         {
             if (report.summary.platform != BuildTarget.Android) return;
-            // Change Gradle path when running in headless mode (CI Machine)
+            
+            // Configure Gradle path for CI builds
             if (!Application.isBatchMode) return;
+            
             if (!GDKCIBuildCommand.TryGetEnv("GRADLE_PATH", out string envGradlePath)) return;
-            EditorPrefs.SetBool("GradleUseEmbedded", false);
-            EditorPrefs.SetString("GradlePath", envGradlePath);
-            Debug.Log("Update gradle path to: " + envGradlePath);
-
+            
+            try
+            {
+                EditorPrefs.SetBool("GradleUseEmbedded", false);
+                EditorPrefs.SetString("GradlePath", envGradlePath);
+                Debug.Log($"Updated Gradle path to: {envGradlePath}");
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"Failed to set Gradle path: {ex.Message}");
+            }
         }
     }
+    
+    #endregion
 }

package/Editor/Extra/GDKLocalBuild.cs

@@ -211,7 +211,18 @@ namespace Amanotes.Editor
         private void ExportBuild(BuildInfo info)
         {
             string fullBuildPath = info.fullBuildPath(buildFolder);
-            BuildPipeline.BuildPlayer(GetScenes(), fullBuildPath, info.target, BuildOptions.None);
+            
+            // Use BuildPlayerOptions instead of deprecated overload for Unity 6 compatibility
+            var buildPlayerOptions = new BuildPlayerOptions
+            {
+                scenes = GetScenes(),
+                locationPathName = fullBuildPath,
+                target = info.target,
+                targetGroup = BuildPipeline.GetBuildTargetGroup(info.target),
+                options = BuildOptions.None
+            };
+            
+            BuildPipeline.BuildPlayer(buildPlayerOptions);
             info.PostProcessBuild(buildFolder);
 
             // if (buildRQ.willRunSHPostBuild)

package/Editor/Extra/GDKPostBuildAsset.cs

@@ -201,6 +201,24 @@ namespace Amanotes.Editor
                 Debug.Log($"Set build property: {property.key} = {property.value}");
             }
         }
+        
+        static PBXCapabilityType CapabilityFromString(string name)
+        {
+            return name switch
+            {
+                "iCloud"                 => PBXCapabilityType.iCloud,
+                "InAppPurchase"          => PBXCapabilityType.InAppPurchase,
+                "GameCenter"             => PBXCapabilityType.GameCenter,
+                "PushNotifications"      => PBXCapabilityType.PushNotifications,
+                "Wallet"                 => PBXCapabilityType.Wallet,
+                "ApplePay"               => PBXCapabilityType.ApplePay,
+                "PersonalVPN"            => PBXCapabilityType.PersonalVPN,
+                "HealthKit"              => PBXCapabilityType.HealthKit,
+                "HomeKit"                => PBXCapabilityType.HomeKit,
+                // add any others you use…
+                _ => throw new ArgumentException($"Unknown capability: {name}")
+            };
+        }
 
             // Enable Capabilities
         private void AddCapabilities(PBXProject proj, string pathToBuildProject, string targetGuid)
@@ -209,7 +227,7 @@ namespace Amanotes.Editor
             {
                 if (!capability.enable) continue;
 
-                var pbxCapabilityType = PBXCapabilityType.StringToPBXCapabilityType(capability.type);
+                var pbxCapabilityType = CapabilityFromString(capability.type);
                 if (pbxCapabilityType == null)
                 {
                     Debug.LogError($"Unknown capability type: {capability.type}");
@@ -225,12 +243,12 @@ namespace Amanotes.Editor
                         continue;
                     }
                     proj.AddCapability(targetGuid, pbxCapabilityType, entitlementsPath);
-                    Debug.Log($"Added capability: {pbxCapabilityType.id} with entitlements: {entitlementsPath}");
+                    Debug.Log($"Added capability: {pbxCapabilityType} with entitlements: {entitlementsPath}");
                 }
                 else
                 {
                     proj.AddCapability(targetGuid, pbxCapabilityType);
-                    Debug.Log($"Added capability: {pbxCapabilityType.id}");
+                    Debug.Log($"Added capability: {pbxCapabilityType}");
                 }
             }
         }

package/Runtime/Ad/AdLogic.cs

@@ -207,7 +207,11 @@ namespace Amanotes.Core.Internal
             if (!isAdReady)
             {
                 yield return HandleNotReadyAd();
-                if (_showState == ShowAdsState.ShowFail) yield break;
+                if (_showState != ShowAdsState.WaitForAd || _loadState != LoadAdsState.Ready || !isAdReady)
+                {
+                    Log($"[Ad] Terminate ShowAdRoutine _showState ${_showState.ToString()}  _loadState: {_loadState.ToString()} || isAdReady: {isAdReady}");
+                    yield break;
+                }
             }
 
             yield return ExecuteAdShow();

package/Runtime/AmaGDK.cs

@@ -27,7 +27,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.87";
+        public const string VERSION = "0.2.89";
         
         internal static Status _status = Status.None;
         internal static ConfigAsset _config = null;

package/Runtime/Internal/AmaGDK.WebUtils.cs

@@ -136,22 +136,32 @@ namespace Amanotes.Core.Internal
 
         public static IEnumerator CheckInternet(Action<bool> hasInternet)
         {
-            UnityWebRequest www = new UnityWebRequest(AmaGDK.Config.common.internetCheckUrl);
-            yield return www.SendWebRequest();
+            try
+            {
+                UnityWebRequest www = UnityWebRequest.Get(AmaGDK.Config.common.internetCheckUrl);
+                www.timeout = 10; // Set a reasonable timeout
+                yield return www.SendWebRequest();
 
-            if (www.error != null && www.responseCode != 429) //429 = Too many requests
+                if (www.result != UnityWebRequest.Result.Success && www.responseCode != 429) //429 = Too many requests
+                {
+                    hasInternet?.Invoke(false);
+                    yield break;
+                }
+
+                hasInternet?.Invoke(true);
+            }
+            catch (System.Exception ex)
             {
+                // Log the exception but assume no internet connection
+                LogWarning($"Internet check failed with exception: {ex.Message}");
                 hasInternet?.Invoke(false);
-                yield break;
             }
-
-            hasInternet?.Invoke(true);
         }
     }
 
     public partial class SDKConfig
     {
         [Tooltip("The URL we would use to ping to verify if the app is actually connected to the internet")]
-        public string internetCheckUrl = "http://clients3.google.com/generate_204";
+        public string internetCheckUrl = "https://clients3.google.com/generate_204";
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.amanotes.gdk",
-  "version": "0.2.87",
+  "version": "0.2.89",
   "displayName": "AmaGDK",
   "description": "Amanotes Game Development Kit",
   "unity": "2020.3",