com.amanotes.gdk 0.2.80 → 0.2.81-a2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.2.81-a2] - 2024-11-21
+- [Dev] Add GDKPostBuild for iOS
+- [Dev] Improve GDK editor experience before config asset imported
+- [Dev] Analytics save file in async
+- [Dev] Move GDKFileUtils to a separated file
+- [Dev] Update game ops model
+- [Dev] Add ABLab
+- [Dev] Move imported GDK Adapter from RawData to Modules
+
 ## [0.2.80] - 2024-11-13
 - [Dev] Don't use obsolete functions
 - [Dev] Add CrashlyticHook

package/Editor/AmaGDKEditor.cs

@@ -57,20 +57,21 @@ namespace Amanotes.Editor
 
         public void OnEnable()
         {
+            if (sdk == target) return;
+            
             sdk = (AmaGDK)target;
             if (sdk != null) sdk.transform.hideFlags = HideFlags.HideInInspector;
-
             SDKStatus.ClearCache();
             RefreshConfigStatus();
-	        RefreshListAdapters();
+            RefreshListAdapters();
         }
 
         internal enum ConfigAssetStatus
         {
             None,
             ScriptNotFound,
+            ImportConfigPackage,
             AssetNotFound,
-            AssetIsInvalid,
             AssetOk
         }
         
@@ -78,6 +79,8 @@ namespace Amanotes.Editor
 
         void RefreshConfigStatus()
         {
+            AmaGDK._hasLoadConfig = false;
+            
             string[] scriptGUIDs = AssetDatabase.FindAssets("t:MonoScript AmaGDKConfigAsset");
             if (scriptGUIDs.Length == 0)
             {
@@ -85,14 +88,13 @@ namespace Amanotes.Editor
                 return;
             }
             
-            string[] assetGUIDs = AssetDatabase.FindAssets("t:ConfigAsset");
+            string[] assetGUIDs = AssetDatabase.FindAssets("t:AmaGDKConfigAsset");
             if (assetGUIDs.Length == 0)
             {
                 cfgStatus = ConfigAssetStatus.AssetNotFound;
                 return;
             }
             
-            cfgStatus = configAsset != null ? ConfigAssetStatus.AssetOk : ConfigAssetStatus.AssetIsInvalid;
             if (cfgStatus == ConfigAssetStatus.AssetOk) adapterScanned = false;
         }
         
@@ -261,22 +263,30 @@ namespace Amanotes.Editor
         void DrawGUI_GDKConfig()
         {
             if (cfgStatus == ConfigAssetStatus.None) RefreshConfigStatus();
-            if (cfgStatus == ConfigAssetStatus.ScriptNotFound
-                || cfgStatus == ConfigAssetStatus.AssetIsInvalid)
+            if (cfgStatus == ConfigAssetStatus.ScriptNotFound)
             {
-                // Automatically import GDKConfigAsset
+                cfgStatus = ConfigAssetStatus.ImportConfigPackage;
+                AmaGDK._hasLoadConfig = false;
                 AssetDatabase.ImportPackage(Res.AMAGDK_CONFIG_PACKAGE, false);
                 return;
             }
             
+            if (cfgStatus == ConfigAssetStatus.ImportConfigPackage)
+            {
+                EditorGUILayout.HelpBox("Importing AmaGDKConfig package...", MessageType.Info);
+                return;
+            }
+            
             if (cfgStatus == ConfigAssetStatus.AssetNotFound)
             {
-                EditorGUILayout.HelpBox("[Warning] <Resources/AmaGDKConfig.asset> NOT FOUND!\nYou need to create one to control all the adapter's configurations!", MessageType.Warning);
+                EditorGUILayout.HelpBox("[Warning] <Resources/AmaGDKConfig.asset> NOT FOUND or INVALID!\nYou need to create one to control all the adapter's configurations!", MessageType.Warning);
                 GUILayout.BeginHorizontal();
                 {
                     if (AmaGUI.BigButton("CREATE", 40f, BLUE))
                     {
                         CreateGDKConfig();
+                        
+                        cfgStatus = ConfigAssetStatus.None;
                         RefreshConfigStatus();
                     }
 
@@ -291,6 +301,9 @@ namespace Amanotes.Editor
             
             if (configAsset == null)
             {
+                AmaGDK._hasLoadConfig = false;
+                Resources.UnloadUnusedAssets();
+                
                 Debug.LogWarning("Have you just deleted AmaGDKConfig.asset?" + cfgStatus);
                 cfgStatus = ConfigAssetStatus.None;
                 Repaint();

package/Editor/Extra/GDKCIBuildCommand.cs

@@ -24,32 +24,58 @@ namespace Amanotes.Core
         private const string VERSION_NUMBER_VAR = "VERSION_NUMBER_VAR";
         private const string VERSION_iOS = "VERSION_BUILD_VAR";
         
-        public static void InstallPod(EventHandler processExit)
+        public static void InstallPod(EventHandler processExit, string buildPath = null)
         {
             try
             {
-                if (TryGetEnv("CI_SCRIPT_DIR", out string scriptDir))
+                var arguments = $"-c \"/usr/local/bin/pod install --project-directory={buildPath}\"";
+                if (Application.isBatchMode && TryGetEnv("CI_SCRIPT_DIR", out string scriptDir))
                 {
-                    var startInfo = new ProcessStartInfo()
-                    {
-                        FileName = "/bin/bash",
-                        Arguments = $"{scriptDir}/utils.sh pod-install",
-                        CreateNoWindow = true
-                    };
-                    var proc = new Process
-                    {
-                        StartInfo = startInfo,
-                        EnableRaisingEvents = true
-                    };
-                    proc.Exited += processExit;
-                    proc.Start();
-                    proc.WaitForExit();
+                    arguments = $"{scriptDir}/utils.sh pod-install";
                 }
-                else
+                
+                // Configure process start info
+                var startInfo = new ProcessStartInfo
                 {
-                    Debug.Log("Failed to run pod install: $CI_SCRIPT_DIR not found");
-                }
-            } catch (Exception e)
+                    FileName = "/bin/zsh",
+                    Arguments = arguments,
+                    CreateNoWindow = false,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+                    UseShellExecute = false
+                };
+
+                var proc = new Process
+                {
+                    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.ErrorDataReceived += (sender, args) =>
+                // {
+                //     if (args.Data == null) return; // End of the stream
+                //     Debug.LogError(args.Data);
+                // };
+
+                proc.Exited += processExit;
+
+                // Start the process
+                proc.Start();
+                proc.BeginOutputReadLine();
+                proc.BeginErrorReadLine();
+                proc.WaitForExit();
+
+                // Log exit code
+                // Debug.LogWarning("Process exited with code: " + proc.ExitCode);
+            }
+            catch (Exception e)
             {
                 Debug.LogError(e);
             }

package/Editor/Extra/GDKPostBuildAsset.cs

@@ -0,0 +1,376 @@
+using UnityEngine;
+using UnityEditor;
+
+using System.IO;
+using System.Collections.Generic;
+using UnityEditor.Callbacks;
+
+#if UNITY_IOS
+using Amanotes.Core;
+using UnityEditor.iOS.Xcode;
+using UnityEditor.iOS.Xcode.Extensions;
+#endif
+
+namespace Amanotes.Editor
+{
+    [CreateAssetMenu(fileName = "GDKPostBuildAsset", menuName = "Ama GDK/GDKPostBuildAsset", order = 1)]
+    public class GDKPostBuildAsset : ScriptableObject
+    {
+        [System.Serializable]
+        public class Framework
+        {
+            public string name;
+            public bool enable;
+            public bool isWeak;
+        }
+
+        [System.Serializable]
+        public class PodFramework
+        {
+            public string relativePath; // Only the framework name, e.g., "AppLovinSDK"
+            public bool enable;
+        }
+
+        [System.Serializable]
+        public class PlistKey
+        {
+            public string key;
+            public string value;
+            public bool isString;
+            public bool enable;
+        }
+
+        [System.Serializable]
+        public class BuildProperty
+        {
+            public string key;
+            public string value;
+            public bool enable;
+        }
+
+        [System.Serializable]
+        public class Capability
+        {
+            public string type;
+            public string entitlementFile;
+            public bool enable;
+        }
+
+        [Header("Frameworks to Add")]
+        public List<Framework> frameworks = new List<Framework>
+        {
+            new Framework { name = "iAd.framework", enable = true, isWeak = false },
+            new Framework { name = "AdSupport.framework", enable = true, isWeak = false },
+            new Framework { name = "CoreData.framework", enable = true, isWeak = false },
+            new Framework { name = "Security.framework", enable = true, isWeak = false },
+            new Framework { name = "UserNotifications.framework", enable = true, isWeak = false },
+            new Framework { name = "UIKit.framework", enable = true, isWeak = false },
+            new Framework { name = "WebKit.framework", enable = true, isWeak = false },
+            new Framework { name = "CoreGraphics.framework", enable = true, isWeak = false },
+            new Framework { name = "SystemConfiguration.framework", enable = true, isWeak = false },
+            new Framework { name = "MobileCoreServices.framework", enable = true, isWeak = false },
+            new Framework { name = "AppTrackingTransparency.framework", enable = true, isWeak = false }
+        };
+
+        [Header("Pod Frameworks to Add")]
+        public List<PodFramework> podFrameworks = new List<PodFramework>
+        {
+            new PodFramework { relativePath = "AppLovinSDK", enable = true },
+            new PodFramework { relativePath = "InMobiSDK", enable = true }
+        };
+
+        [Header("Info.plist Keys to Add")]
+        public List<PlistKey> plistKeys = new List<PlistKey>
+        {
+            new PlistKey { key = "NSCalendarsUsageDescription", value = "App requires calendar access.", isString = true, enable = true },
+            new PlistKey { key = "NSCameraUsageDescription", value = "App requires camera access.", isString = true, enable = true },
+            new PlistKey { key = "NSPhotoLibraryUsageDescription", value = "App requires photo library access.", isString = true, enable = true },
+            new PlistKey { key = "NSMotionUsageDescription", value = "App requires motion control.", isString = true, enable = true },
+            new PlistKey { key = "NSLocationWhenInUseUsageDescription", value = "App requires location access.", isString = true, enable = true },
+            new PlistKey { key = "NSUserTrackingUsageDescription", value = "App requires user tracking permission.", isString = true, enable = true }
+        };
+
+        [Header("Build Properties to Set")]
+        public List<BuildProperty> buildProperties = new List<BuildProperty>
+        {
+            new BuildProperty { key = "ENABLE_BITCODE", value = "NO", enable = true },
+            new BuildProperty { key = "VERSIONING_SYSTEM", value = "apple-generic", enable = true },
+            new BuildProperty { key = "CURRENT_PROJECT_VERSION", value = "1", enable = true },
+            new BuildProperty { key = "CODE_SIGN_STYLE", value = "Manual", enable = true }
+        };
+
+        [Header("Capabilities to Enable")]
+        public List<Capability> capabilities = new List<Capability>
+        {
+            new Capability { type = "com.apple.Push", entitlementFile = "amanotes.entitlements", enable = true },
+            new Capability { type = "com.apple.InAppPurchase", entitlementFile = "", enable = true },
+            new Capability { type = "com.apple.BackgroundModes", entitlementFile = "", enable = true }
+        };
+
+        public string lastBuildPath;
+
+#if UNITY_IOS
+        private const string PLIST_FILE = "Info.plist";
+        private const string EXIST_ON_SUSPEND_KEY = "UIApplicationExitsOnSuspend";
+
+        public void ExecutePostBuild(string pathToBuildProject)
+        {
+            lastBuildPath = pathToBuildProject;
+            
+            if (string.IsNullOrEmpty(pathToBuildProject))
+            {
+                Debug.LogError("Path to build project is null or empty.");
+                return;
+            }
+
+            string projectPath = PBXProject.GetPBXProjectPath(pathToBuildProject);
+            if (!File.Exists(projectPath))
+            {
+                Debug.LogError($"Xcode project file not found at {projectPath}");
+                return;
+            }
+
+            var proj = new PBXProject();
+            proj.ReadFromFile(projectPath);
+
+#if UNITY_2020_1_OR_NEWER
+            string frameworkTargetGuid = proj.GetUnityFrameworkTargetGuid();
+            string mainTargetGuid = proj.GetUnityMainTargetGuid();
+#else
+            string frameworkTargetGuid = proj.TargetGuidByName("UnityFramework");
+            string mainTargetGuid = proj.TargetGuidByName("Unity-iPhone");
+#endif
+
+            // Remove deprecated Info.plist keys
+            RemoveDeprecatedInfoPListKeys(pathToBuildProject);
+            if (string.IsNullOrEmpty(mainTargetGuid))
+            {
+                Debug.LogError("Main target GUID is null or empty.");
+                return;
+            }
+
+            SetBuildProperties(proj, mainTargetGuid);
+            AddCapabilities(proj, pathToBuildProject, mainTargetGuid);
+            AddFrameworks(proj, mainTargetGuid);
+            
+            GDKCIBuildCommand.InstallPod((sender, e) =>
+            {
+                AddPodFrameworks(proj, pathToBuildProject, mainTargetGuid);
+                ModifyInfoPlist(pathToBuildProject);
+                proj.WriteToFile(projectPath);
+            }, pathToBuildProject);
+        }
+        
+        private void RemoveDeprecatedInfoPListKeys(string pathToBuildProject)
+        {
+            string plistPath = Path.Combine(pathToBuildProject, PLIST_FILE);
+            PlistDocument plist = new PlistDocument();
+            plist.ReadFromString(File.ReadAllText(plistPath));
+
+            PlistElementDict rootDict = plist.root;
+
+            if (rootDict.values.ContainsKey(EXIST_ON_SUSPEND_KEY))
+            {
+                Debug.Log($"Removing deprecated key \"{EXIST_ON_SUSPEND_KEY}\" from \"{PLIST_FILE}\".");
+                rootDict.values.Remove(EXIST_ON_SUSPEND_KEY);
+            }
+
+            File.WriteAllText(plistPath, plist.WriteToString());
+        }
+
+        private void SetBuildProperties(PBXProject proj, string targetGuid)
+        {
+            foreach (var property in buildProperties)
+            {
+                if (!property.enable) continue;
+                proj.SetBuildProperty(targetGuid, property.key, property.value);
+                Debug.Log($"Set build property: {property.key} = {property.value}");
+            }
+        }
+
+            // Enable Capabilities
+        private void AddCapabilities(PBXProject proj, string pathToBuildProject, string targetGuid)
+        {
+            foreach (var capability in capabilities)
+            {
+                if (!capability.enable) continue;
+
+                var pbxCapabilityType = PBXCapabilityType.StringToPBXCapabilityType(capability.type);
+                if (pbxCapabilityType == null)
+                {
+                    Debug.LogError($"Unknown capability type: {capability.type}");
+                    continue;
+                }
+
+                if (!string.IsNullOrEmpty(capability.entitlementFile))
+                {
+                    string entitlementsPath = Path.Combine(pathToBuildProject, capability.entitlementFile);
+                    if (!File.Exists(entitlementsPath))
+                    {
+                        Debug.LogError($"Entitlements file not found: {entitlementsPath}");
+                        continue;
+                    }
+                    proj.AddCapability(targetGuid, pbxCapabilityType, entitlementsPath);
+                    Debug.Log($"Added capability: {pbxCapabilityType.id} with entitlements: {entitlementsPath}");
+                }
+                else
+                {
+                    proj.AddCapability(targetGuid, pbxCapabilityType);
+                    Debug.Log($"Added capability: {pbxCapabilityType.id}");
+                }
+            }
+        }
+
+        private void AddFrameworks(PBXProject proj, string targetGuid)
+        {
+            foreach (var framework in frameworks)
+            {
+                if (!framework.enable) continue;
+                proj.AddFrameworkToProject(targetGuid, framework.name, framework.isWeak);
+                Debug.Log($"Added framework: {framework.name} (Weak: {framework.isWeak})");
+            }
+        }
+
+        private void AddPodFrameworks(PBXProject proj, string pathToBuildProject, string targetGuid)
+        {
+            string podsDirectory = Path.Combine(pathToBuildProject, "Pods");
+            if (!Directory.Exists(podsDirectory))
+            {
+                Debug.LogError($"Pods directory not found. Ensure pod install has completed successfully.");
+                return;
+            }
+
+            foreach (var podFramework in podFrameworks)
+            {
+                if (!podFramework.enable) continue;
+
+                string frameworkPath = SearchForPodFramework(pathToBuildProject, podFramework.relativePath);
+                if (string.IsNullOrEmpty(frameworkPath))
+                {
+                    Debug.LogError($"Failed to find Pod framework for: {podFramework.relativePath}");
+                    continue;
+                }
+
+                string fileGuid = proj.AddFile(frameworkPath, frameworkPath, PBXSourceTree.Source);
+                if (string.IsNullOrEmpty(fileGuid))
+                {
+                    Debug.LogError($"Failed to add Pod framework: {frameworkPath}");
+                    continue;
+                }
+
+                proj.AddFileToEmbedFrameworks(targetGuid, fileGuid);
+
+                // Set CODE_SIGN_ON_COPY for Debug and Release configurations
+                // string debugConfig = proj.BuildConfigByName(targetGuid, "Debug");
+                // string releaseConfig = proj.BuildConfigByName(targetGuid, "Release");
+                //
+                // if (!string.IsNullOrEmpty(debugConfig))
+                // {
+                //     proj.SetBuildProperty(debugConfig, "CODE_SIGN_ON_COPY", "YES");
+                // }
+                //
+                // if (!string.IsNullOrEmpty(releaseConfig))
+                // {
+                //     proj.SetBuildProperty(releaseConfig, "CODE_SIGN_ON_COPY", "YES");
+                // }
+
+                Debug.Log($"Added Pod framework to Embed Frameworks: {frameworkPath}");
+            }
+        }
+        
+        private void ModifyInfoPlist(string pathToBuildProject)
+        {
+            string plistPath = Path.Combine(pathToBuildProject, PLIST_FILE);
+            if (!File.Exists(plistPath))
+            {
+                Debug.LogError($"Info.plist file not found at {plistPath}");
+                return;
+            }
+
+            var plist = new PlistDocument();
+            plist.ReadFromFile(plistPath);
+            var rootDict = plist.root;
+
+            foreach (var plistKey in plistKeys)
+            {
+                if (!plistKey.enable) continue;
+
+                if (plistKey.isString)
+                {
+                    rootDict.SetString(plistKey.key, plistKey.value);
+                }
+                else if (bool.TryParse(plistKey.value, out bool boolValue))
+                {
+                    rootDict.SetBoolean(plistKey.key, boolValue);
+                }
+
+                Debug.Log($"Added/Updated Info.plist key: {plistKey.key}");
+            }
+
+            plist.WriteToFile(plistPath);
+        }
+
+        private string SearchForPodFramework(string projectPath, string podFrameworkName)
+        {
+            string podsDirectory = Path.Combine(projectPath, "Pods", podFrameworkName);
+
+            if (!Directory.Exists(podsDirectory))
+            {
+                Debug.LogError($"Pods directory not found for: {podFrameworkName}");
+                return null;
+            }
+
+            // Recursively search for directories named {POD_FRAMEWORK_NAME}.xcframework
+            string[] frameworkPaths = Directory.GetDirectories(podsDirectory, $"{podFrameworkName}.xcframework", SearchOption.AllDirectories);
+
+            if (frameworkPaths.Length > 0)
+            {
+                Debug.Log($"Found framework for {podFrameworkName}: {frameworkPaths[0]}");
+                return frameworkPaths[0];
+            }
+
+            Debug.LogError($"No .xcframework folder found for {podFrameworkName} in {podsDirectory}");
+            return null;
+        }
+
+        [PostProcessBuild]
+        public static void OnPostprocessBuild(BuildTarget target, string pathToBuildProject)
+        {
+            if (target != BuildTarget.iOS) return;
+
+            GDKPostBuildAsset postBuildAsset = FindGDKPostBuildAsset();
+            if (postBuildAsset == null) return;
+
+            Debug.Log($"Post processing: {pathToBuildProject}");
+            postBuildAsset.ExecutePostBuild(pathToBuildProject);
+        }
+
+        [MenuItem("Window/AmaGDK/Postprocess Build iOS")]
+        public static void RunPostBuildIOS()
+        {
+            var buildAsset = FindGDKPostBuildAsset(); 
+            if (buildAsset == null) return;
+            
+            if (string.IsNullOrEmpty(buildAsset.lastBuildPath))
+            {
+                buildAsset.lastBuildPath = Path.GetFullPath("../../_Build/XCode_PHB3_v2.13.3_b200611");
+            }
+            
+            OnPostprocessBuild(BuildTarget.iOS, buildAsset.lastBuildPath);
+        }
+
+        public static GDKPostBuildAsset FindGDKPostBuildAsset()
+        {
+            string[] guids = AssetDatabase.FindAssets("t:GDKPostBuildAsset");
+            if (guids.Length == 0)
+            {
+                Debug.LogError("No GDKPostBuildAsset found in the project.");
+                return null;
+            }
+
+            string path = AssetDatabase.GUIDToAssetPath(guids[0]);
+            return AssetDatabase.LoadAssetAtPath<GDKPostBuildAsset>(path);
+        }
+#endif
+    }
+}

package/Editor/Extra/GDKPostBuildAsset.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e1f86b36b12bb4965b3d96d737729f17
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Extra/SDKVersionTracking.cs

@@ -270,7 +270,6 @@ namespace Amanotes.Editor
         public static void OnPostProcessBuild(BuildTarget target, string pathToBuiltProject)
         {
             var rawData = _dicThirdPartyVersion
-                .Concat(_dicImportedGDKAdapter)
                 .Concat(_dicExtraVersion)
                 .Concat(_dicIronSourceAdapterVersion.ToDictionary(kvp => kvp.Key, kvp => (object)("IS_" + kvp.Value)))
                 .ToDictionary(x => x.Key, x => x.Value);
@@ -293,8 +292,10 @@ namespace Amanotes.Editor
                 {"BuildTime", GetBuildTime()},
                 {"AppId", PlayerSettings.applicationIdentifier },
                 {"Platform", platform},
+                {"Modules", _dicImportedGDKAdapter },
                 {"RawData", rawData }
             };
+
             string json = JsonUtils.DictionaryToJson(buildInfo, false, false);
             Task.Run(()=>SendDataToAirTable(json));
         }

package/Runtime/Ad/AmaGDK.Ads.cs

@@ -93,7 +93,7 @@ namespace Amanotes.Core
             
             internal void Save()
             {
-                this.SaveJsonToFile();
+                this.SaveJsonToFile(false);
             }
         }
 

package/Runtime/AmaGDK.Analytics.cs

@@ -135,7 +135,7 @@ namespace Amanotes.Core
                 
                 if (!localData._dirty) return;
                 localData._dirty = false;
-                localData.SaveJsonToFile();
+                localData.SaveJsonToFile(true); // immediately = true
             }
 
             public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "")
@@ -314,7 +314,7 @@ namespace Amanotes.Core
             internal static readonly GDKPool.Pool<EventParams> epPool = new GDKPool.Pool<EventParams>(1);
 
             private static readonly Lazy<AnalyticsData> _localData = new Lazy<AnalyticsData>(
-                () => new AnalyticsData().LoadJsonFromFile().BuildCache());
+                () => new AnalyticsData().ReloadDataFromLocal());
             internal static AnalyticsData localData => _localData.Value;
             
             internal static readonly Dictionary<string, string> reservedPrefixes = new Dictionary<string, string>()
@@ -800,6 +800,12 @@ namespace Amanotes.Core
                     return this;
                 }
                 
+                public AnalyticsData ReloadDataFromLocal()
+                {
+                    this.LoadJsonFromFile().BuildCache();
+                    return this;
+                }
+                
                 internal EventDetail GetEventDetail(string eventName, bool autoNew = false)
                 {
                     if (string.IsNullOrEmpty(eventName)) return null;
@@ -843,7 +849,7 @@ namespace Amanotes.Core
                     if (!Config.analytics.autoFlushEventDetail) return;
                     if (!_dirty) return;
                     _dirty = false;
-                    this.SaveJsonToFile();
+                    this.SaveJsonToFile(false);
                 }
 
                 internal void UpdateMigrationLog()

package/Runtime/AmaGDK.Consent.cs

@@ -66,7 +66,7 @@ namespace Amanotes.Core
                     ConsentHook.ATTRequest(isAllowed =>
                     {
                         data.att = isAllowed ? Status.Allowed : Status.NotAllowed;
-                        data.SaveJsonToFile();
+                        data.SaveJsonToFile(false);
                         onComplete?.Invoke(allowedATT);
                     });
                 }
@@ -107,7 +107,7 @@ namespace Amanotes.Core
                         if (successful)
                         {
                             data.cmp = !IsRequired ? Status.NotRequired : Status.Allowed;
-                            data.SaveJsonToFile();
+                            data.SaveJsonToFile(false);
                         }
                         onComplete?.Invoke(checkedCMP);
                     });

package/Runtime/AmaGDK.IAP.cs

@@ -306,7 +306,7 @@ namespace Amanotes.Core
                     subscriptionExpiredDate = _subscriptionExpiredDate?.ToString(DATE_FORMAT);
                     _unsubscribedDate = Adapter.GetUnsubscribedDate();
                     unsubscribedDate = _unsubscribedDate?.ToString(DATE_FORMAT);
-                    this.SaveJsonToFile();
+                    this.SaveJsonToFile(false);
                 }
             }
         }

package/Runtime/AmaGDK.UserProfile.cs

@@ -33,14 +33,14 @@ namespace Amanotes.Core
             private bool _dirty = false;
             private void Save()
             {
-                this.SaveJsonToFile();
+                this.SaveJsonToFile(false);
             }
             
             private void SaveIfDirty()
             {
                 if (!_dirty) return;
                 _dirty = false;
-                this.SaveJsonToFile();
+                this.SaveJsonToFile(false);
             }
         }
 

package/Runtime/AmaGDK.cs

@@ -27,10 +27,10 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.80";
+        public const string VERSION = "0.2.81-a2";
         
         internal static Status _status = Status.None;
-        private static ConfigAsset _config = null;
+        internal static ConfigAsset _config = null;
         
         private static readonly Lazy<GDKGeoLocation> _geoLocation = new Lazy<GDKGeoLocation>(() => new GDKGeoLocation());
         private static readonly Lazy<GDKServerTime> _serverTime = new Lazy<GDKServerTime>(() => new GDKServerTime());
@@ -41,7 +41,8 @@ namespace Amanotes.Core
         internal static GDKServerTime ServerTime => _serverTime.Value;
         private static ForceQuitMonitor ForceQuit => _forceQuit.Value;
         
-        internal static bool _allowInit = false;
+        [NonSerialized] internal static bool _allowInit = false;
+        [NonSerialized] internal static bool _hasLoadConfig = false;
         
         public bool autoInit = true;
         
@@ -65,8 +66,10 @@ namespace Amanotes.Core
         {
             get
             {
-                if (_config != null) return _config;
+                if (_config != null || _hasLoadConfig) return _config;
+                _hasLoadConfig = true;
                 var config = Resources.Load<ConfigAsset>("AmaGDKConfig");
+                
                 #if UNITY_EDITOR
                 if (EditorApplication.isPlayingOrWillChangePlaymode)
                 {

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -56,11 +56,19 @@ namespace Amanotes.Core.Internal
                 return;
             }
 
-            GameObject go = UnityObject.Instantiate(prefab);
-            go.name = "AmaGDK";
-            go.transform.SetAsLastSibling();
+            tempGO = UnityObject.Instantiate(prefab);
+            tempGO.name = "AmaGDK";
+            tempGO.transform.SetAsLastSibling();
             Selection.activeObject = null;
-            Selection.activeObject = go;
+            EditorApplication.update -= DelaySelect;
+            EditorApplication.update += DelaySelect;
+        }
+        
+        private static GameObject tempGO;
+        private static void DelaySelect()
+        {
+            EditorApplication.update -= DelaySelect;
+            Selection.activeObject = tempGO;
         }
 #endif
     }

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -128,230 +127,7 @@ namespace Amanotes.Core.Internal
         }
         
     }
-
-    public static class GDKFileUtils
-    {
-        private static string _basePath;
-        public static string basePath
-        {
-            get
-            {
-                if (!string.IsNullOrEmpty(_basePath)) return _basePath;
-                _basePath = Application.isEditor
-                    ? Path.Combine(Directory.GetCurrentDirectory(), "Library", "AmaGDK")
-                    : Path.Combine(Application.persistentDataPath, "AmaGDK");
-
-                if (!Directory.Exists(_basePath)) Directory.CreateDirectory(_basePath);
-                return _basePath;
-            }
-        }
-        
-        internal static string GetPath(string fileName)
-        {
-            return Path.Combine(basePath, fileName);
-        }
-
-        internal static bool Exist(string fileName)
-        {
-            return File.Exists(GetPath(fileName));
-        }
-
-        public static void Save(string fileName, string content)
-        {
-            if (string.IsNullOrWhiteSpace(fileName))
-            {
-                LogWarningOnce("File name must be not null or empty");
-                return;
-            }
-
-            if (string.IsNullOrWhiteSpace(content))
-            {
-                LogWarningOnce($"Content for {fileName} is empty");
-            }
-
-            string path = GetPath(fileName);
-
-            try
-            {
-                File.WriteAllText(path, content);
-            }
-            catch (Exception ex)
-            {
-                LogWarningOnce(path + "\n" + ex);
-            }
-        }
-
-        internal static void SaveAppend(string fileName, IEnumerable<string> contents)
-        {
-            if (string.IsNullOrWhiteSpace(fileName))
-            {
-                LogWarningOnce("File name must be not null or empty");
-                return;
-            }
-            
-            if (contents == null || !contents.GetEnumerator().MoveNext())
-            {
-                LogWarningOnce($"Content for {fileName} is empty");
-            }
-
-            string path = GetPath(fileName);
-            try
-            {
-                File.AppendAllLines(path, contents);
-            }
-            catch (Exception ex)
-            {
-                LogWarningOnce(path + "\n" + ex);
-            }
-        }
-
-        internal static void SaveAppend(string fileName, string content)
-        {
-            if (string.IsNullOrWhiteSpace(fileName))
-            {
-                LogWarningOnce("File name must be not null or empty");
-                return;
-            }
-
-            if (string.IsNullOrWhiteSpace(content))
-            {
-                LogWarningOnce($"Content for {fileName} is empty");
-            }
-
-            string path = GetPath(fileName);
-            try
-            {
-                File.AppendAllText(path, content);
-            }
-            catch (Exception ex)
-            {
-                LogWarningOnce(path + "\n" + ex);
-            }
-        }
-
-        public static string Load(string fileName)
-        {
-            var content = "";
-
-            if (string.IsNullOrWhiteSpace(fileName))
-            {
-                LogWarningOnce("File name must be not null or empty");
-                return content;
-            }
-
-            string path = GetPath(fileName);
-            if (!File.Exists(path)) return content;
-
-            try
-            {
-                content = File.ReadAllText(path);
-            }
-            catch (Exception ex)
-            {
-                LogWarningOnce(path + "\n" + ex);
-            }
-
-            return content;
-        }
-
-        public static async Task<string> LoadFromStreamingAssets(string fileName)
-        {
-            string filePath = Path.Combine(Application.streamingAssetsPath, fileName);
-
-            // Android
-            if (Application.platform == RuntimePlatform.Android)
-            {
-                using (UnityWebRequest request = UnityWebRequest.Get(filePath))
-                {
-                    var operation = request.SendWebRequest();
-                    while (!operation.isDone)
-                    {
-                        await Task.Yield();
-                    }
-                    if (request.result != UnityWebRequest.Result.Success)
-                    {
-                        LogWarning($"Error reading file: {request.error}");
-                        return null;
-                    }
-                    return request.downloadHandler.text;
-                }
-            }
-
-            // Other
-            try
-            {
-                return File.ReadAllText(filePath);
-            }
-            catch (Exception e)
-            {
-                LogWarning($"Error reading file: {e.Message}");
-            }
-            return null;
-        }
-
-        internal static void Delete(string fileName)
-        {
-            string path = GetPath(fileName);
-            if (!File.Exists(path)) return;
-
-            try
-            {
-                File.Delete(path);
-            }
-            catch (Exception ex)
-            {
-                LogWarningOnce(path + "\n" + ex);
-            }
-        }
-        
-        public static void ClearCacheData()
-        {
-            var sb = GDKPool.GetStringBuilder();
-            sb.AppendLine("[AmaGDK] All cached data & stats cleared");
-            
-            if (!Directory.Exists(basePath))
-            {
-                sb.AppendLine("Cache path not exists: " + basePath);
-                return;
-            }
-            
-            string[] filePaths = Directory.GetFiles(basePath);
-            foreach (string path in filePaths)
-            {
-                Delete(path);
-                sb.AppendLine($"[deleted] - {path}");
-            }
-            Debug.Log(sb);
-        }
-        
-        public static T LoadJsonFromFile<T>(T instance) where T: new()
-        {
-            instance ??= new T();
-            
-            string fileName = instance.GetType().Name;
-            string json = Load(fileName);
-            if (!string.IsNullOrEmpty(json))
-            {
-                try
-                {
-                    JsonUtility.FromJsonOverwrite(json, instance);
-                } catch (Exception e)
-                {
-                    LogWarning("LoadJsonFromFile error: " + fileName + "\n" + e);
-                }
-            }
-            
-            return instance;
-        }
-
-        public static void SaveJsonToFile<T>(T instance)
-        {
-            string fileName = instance.GetType().Name;
-            string json = JsonUtility.ToJson(instance);
-            Save(fileName, json);
-        }
-    }
-
+    
     public class ActionQueue
     {
         private bool isProcessing;
@@ -419,14 +195,14 @@ namespace Amanotes.Core.Internal
     
     internal static class JsonFileExtension
     {
-        public static T LoadJsonFromFile<T>(this T instance) where T : IJsonFile, new()
+        internal static T LoadJsonFromFile<T>(this T instance) where T : IJsonFile, new()
         {
             return GDKFileUtils.LoadJsonFromFile(instance);
         }
 
-        public static void SaveJsonToFile<T>(this T instance) where T: IJsonFile
+        internal static void SaveJsonToFile<T>(this T instance, bool immediately) where T: IJsonFile
         {
-            GDKFileUtils.SaveJsonToFile(instance);
+            GDKFileUtils.SaveJsonToFile(instance, immediately);
         }
     }
 

package/Runtime/Internal/ForceQuitMonitor.cs

@@ -34,7 +34,7 @@ namespace Amanotes.Core.Internal
             internal void SaveIfDirty(bool forceSave = false)
             {
                 if (!isDirty && !forceSave) return;
-                this.SaveJsonToFile();
+                this.SaveJsonToFile(true);
                 isDirty = false;
             }
         }

package/Runtime/Utils/GDKFileUtils.cs

@@ -0,0 +1,246 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.Networking;
+using static Amanotes.Core.GDKDebug;
+
+namespace Amanotes.Core.Internal
+{
+    public static class GDKFileUtils
+    {
+        private static string _basePath;
+        public static string basePath
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(_basePath)) return _basePath;
+                _basePath = Application.isEditor
+                    ? Path.Combine(Directory.GetCurrentDirectory(), "Library", "AmaGDK")
+                    : Path.Combine(Application.persistentDataPath, "AmaGDK");
+
+                if (!Directory.Exists(_basePath)) Directory.CreateDirectory(_basePath);
+                return _basePath;
+            }
+        }
+        
+        internal static string GetPath(string fileName)
+        {
+            return Path.Combine(basePath, fileName);
+        }
+
+        internal static bool Exist(string fileName)
+        {
+            return File.Exists(GetPath(fileName));
+        }
+        
+        public static void Save(string fileName, string content, bool immediately = true)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                LogWarningOnce("File name must be not null or empty");
+                return;
+            }
+
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                LogWarningOnce($"Content for {fileName} is empty");
+            }
+            
+            ThreadWrite(fileName, content, immediately);
+        }
+
+        private static void ThreadWrite(string fileName, string content, bool immediately)
+        {
+            // Only write on main thread if immediately is true
+            if (!immediately && GDKUtils.isOnMainThread)
+            {
+                Task.Run(()=>ThreadWrite(fileName, content, true))
+                    .ConfigureAwait(false);
+                return;
+            }
+            
+            string filePath = GetPath(fileName);
+            try
+            {
+                File.WriteAllText(filePath, content);
+            }
+            catch (Exception ex)
+            {
+                LogWarningOnce($"Exception in ThreadWrite(): {filePath}\n{ex}");
+            }
+        }
+
+        internal static void SaveAppend(string fileName, IEnumerable<string> contents)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                LogWarningOnce("File name must be not null or empty");
+                return;
+            }
+            
+            if (contents == null || !contents.GetEnumerator().MoveNext())
+            {
+                LogWarningOnce($"Content for {fileName} is empty");
+            }
+
+            string path = GetPath(fileName);
+            try
+            {
+                File.AppendAllLines(path, contents);
+            }
+            catch (Exception ex)
+            {
+                LogWarningOnce(path + "\n" + ex);
+            }
+        }
+
+        internal static void SaveAppend(string fileName, string content)
+        {
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                LogWarningOnce("File name must be not null or empty");
+                return;
+            }
+
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                LogWarningOnce($"Content for {fileName} is empty");
+            }
+
+            string path = GetPath(fileName);
+            try
+            {
+                File.AppendAllText(path, content);
+            }
+            catch (Exception ex)
+            {
+                LogWarningOnce(path + "\n" + ex);
+            }
+        }
+
+        public static string Load(string fileName)
+        {
+            var content = "";
+
+            if (string.IsNullOrWhiteSpace(fileName))
+            {
+                LogWarningOnce("File name must be not null or empty");
+                return content;
+            }
+
+            string path = GetPath(fileName);
+            if (!File.Exists(path)) return content;
+
+            try
+            {
+                content = File.ReadAllText(path);
+            }
+            catch (Exception ex)
+            {
+                LogWarningOnce(path + "\n" + ex);
+            }
+
+            return content;
+        }
+
+        public static async Task<string> LoadFromStreamingAssets(string fileName)
+        {
+            string filePath = Path.Combine(Application.streamingAssetsPath, fileName);
+
+            // Android
+            if (Application.platform == RuntimePlatform.Android)
+            {
+                using (UnityWebRequest request = UnityWebRequest.Get(filePath))
+                {
+                    var operation = request.SendWebRequest();
+                    while (!operation.isDone)
+                    {
+                        await Task.Yield();
+                    }
+                    if (request.result != UnityWebRequest.Result.Success)
+                    {
+                        LogWarning($"Error reading file: {request.error}");
+                        return null;
+                    }
+                    return request.downloadHandler.text;
+                }
+            }
+
+            // Other
+            try
+            {
+                return File.ReadAllText(filePath);
+            }
+            catch (Exception e)
+            {
+                LogWarning($"Error reading file: {e.Message}");
+            }
+            return null;
+        }
+
+
+        internal static void Delete(string fileName)
+        {
+            string path = GetPath(fileName);
+            if (!File.Exists(path)) return;
+
+            try
+            {
+                File.Delete(path);
+            }
+            catch (Exception ex)
+            {
+                LogWarningOnce(path + "\n" + ex);
+            }
+        }
+        
+        public static void ClearCacheData()
+        {
+            var sb = GDKPool.GetStringBuilder();
+            sb.AppendLine("[AmaGDK] All cached data & stats cleared");
+            
+            if (!Directory.Exists(basePath))
+            {
+                sb.AppendLine("Cache path not exists: " + basePath);
+                return;
+            }
+            
+            string[] filePaths = Directory.GetFiles(basePath);
+            foreach (string path in filePaths)
+            {
+                Delete(path);
+                sb.AppendLine($"[deleted] - {path}");
+            }
+            Debug.Log(sb);
+        }
+        
+        public static T LoadJsonFromFile<T>(T instance) where T: new()
+        {
+            instance ??= new T();
+            
+            string fileName = instance.GetType().Name;
+            string json = Load(fileName);
+            if (!string.IsNullOrEmpty(json))
+            {
+                try
+                {
+                    JsonUtility.FromJsonOverwrite(json, instance);
+                } catch (Exception e)
+                {
+                    LogWarning("LoadJsonFromFile error: " + fileName + "\n" + e);
+                }
+            }
+            
+            return instance;
+        }
+        
+        public static void SaveJsonToFile<T>(T instance, bool immediately)
+        {
+            string fileName = instance.GetType().Name;
+            string json = JsonUtility.ToJson(instance);
+            ThreadWrite(fileName, json, immediately);
+        }
+    }
+}

package/Runtime/Utils/GDKFileUtils.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: eea38fc318cc4eaea93827ed66cdd96f
+timeCreated: 1729828422

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.80",
+    "version": "0.2.81-a2",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",