com.amanotes.gdk 0.2.81-alpha.12 → 0.2.81-alpha.14

package/Runtime/Ad/AdLogic.cs

@@ -8,7 +8,6 @@ namespace Amanotes.Core.Internal
 {
     public abstract class AdLogic
     {
-        private const int MAX_FRAMES_WAIT_FOR_CALLBACK = 60; 
         protected AdModuleConfig adConfig => Config.ad;
         protected AdShowContext context => Ads.context;
         
@@ -256,20 +255,18 @@ namespace Amanotes.Core.Internal
                 }
             };
             unityCallbacks.OnApplicationFocus += onApplicationFocusCallback;
-            int counter = 0;
             while (context != null && !context.potentiallyCompleted)
             {
                 if (hasFocusAgain && hasOutOfFocus)
                 {
-                    // Start counting frames only after closed the ad
-                    counter++;
-                }
-                if (counter > MAX_FRAMES_WAIT_FOR_CALLBACK)
-                {
-                    // Timeout reached, force close the ad
-                    LogError("Force close the ad");
-                    StopShowAd();
-                    break;
+                    // Start counting only after closed the ad
+                    yield return GDKUtils.WaitForSecondsRealtime(Config.ad.adCallBackTimeOut);
+                    if (context != null && !context.potentiallyCompleted)
+                    {
+                        LogError("Force close the ad");
+                        StopShowAd();
+                        break;   
+                    }
                 }
                 yield return null;
             }
@@ -351,24 +348,27 @@ namespace Amanotes.Core.Internal
 
         private void TriggerBeforeAdShow()
         {
-            bool willSaveVolume = Config.ad.autoMute
-                && AudioListener.volume > 0
-                && Ads._savedVolume < 0;
+            if (Application.platform == RuntimePlatform.IPhonePlayer)
+            {
+                bool willSaveVolume = Config.ad.autoMute
+                    && AudioListener.volume > 0
+                    && Ads._savedVolume < 0;
 
-            bool willSaveTimeScale = Config.ad.autoTimeScale
-                && Time.timeScale > 0
-                && Ads._savedTimeScale < 0;
+                bool willSaveTimeScale = Config.ad.autoTimeScale
+                    && Time.timeScale > 0
+                    && Ads._savedTimeScale < 0;
 
-            if (willSaveVolume)
-            {
-                Ads._savedVolume = AudioListener.volume;
-                AudioListener.volume = 0;
-            }
+                if (willSaveVolume)
+                {
+                    Ads._savedVolume = AudioListener.volume;
+                    AudioListener.volume = 0;
+                }
 
-            if (willSaveTimeScale)
-            {
-                Ads._savedTimeScale = Time.timeScale;
-                Time.timeScale = 0;
+                if (willSaveTimeScale)
+                {
+                    Ads._savedTimeScale = Time.timeScale;
+                    Time.timeScale = 0;
+                }
             }
 
             dispatcher.Dispatch(_isInterstitial ? AmaGDK.Event.INTER_SHOW_BEGIN : AmaGDK.Event.REWARD_VIDEO_SHOW_BEGIN);
@@ -377,24 +377,27 @@ namespace Amanotes.Core.Internal
 
         private void TriggerOnAfterAdShow()
         {
-            bool willRestoreVolume = Config.ad.autoMute
-                && AudioListener.volume == 0
-                && Ads._savedVolume > 0;
+            if (Application.platform == RuntimePlatform.IPhonePlayer)
+            {
+                bool willRestoreVolume = Config.ad.autoMute
+                    && Mathf.Approximately(AudioListener.volume, 0)
+                    && Ads._savedVolume > 0;
 
-            bool willRestoreTimeScale = Config.ad.autoTimeScale
-                && Time.timeScale == 0
-                && Ads._savedTimeScale > 0;
+                bool willRestoreTimeScale = Config.ad.autoTimeScale
+                    && Mathf.Approximately(Time.timeScale, 0)
+                    && Ads._savedTimeScale > 0;
 
-            if (willRestoreVolume)
-            {
-                AudioListener.volume = Ads._savedVolume;
-                Ads._savedVolume = -1;
-            }
+                if (willRestoreVolume)
+                {
+                    AudioListener.volume = Ads._savedVolume;
+                    Ads._savedVolume = -1;
+                }
 
-            if (willRestoreTimeScale)
-            {
-                Time.timeScale = Ads._savedTimeScale;
-                Ads._savedTimeScale = -1;
+                if (willRestoreTimeScale)
+                {
+                    Time.timeScale = Ads._savedTimeScale;
+                    Ads._savedTimeScale = -1;
+                }   
             }
             
             bool isSuccess = _showState == ShowAdsState.ShowSuccess;

package/Runtime/Ad/AdModuleConfig.cs

@@ -45,6 +45,9 @@ namespace Amanotes.Core.Internal
         [Header("EDITOR")]
         [Tooltip("Only applicable in Editor\n0 = 0% success\n1 = 100% success")]
         [Range(0f, 1f)] public float rewardAdShowSuccessRate = 1;
+
+        [Tooltip(("The maximum time (in seconds) to wait for the callback response after the ad activity has finished and the app returns to the Unity activity (default = 5s)"))]
+        public float adCallBackTimeOut = 5f;
     }
 
     public partial class ConfigAsset

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

@@ -130,12 +130,11 @@ namespace Amanotes.Core
                 if (Config.analytics.autoFlushEventDetail)
                 {
                     LogWarning("[Analytics] This function FlushEventDetails() is not supposed to be called manually!");
-                    return;
                 }
                 
                 if (!localData._dirty) return;
                 localData._dirty = false;
-                localData.SaveJsonToFile();
+                localData.SaveJsonToFile(false);
             }
 
             public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "")
@@ -648,7 +647,12 @@ namespace Amanotes.Core
             internal static void PostPrepareEventProcess(EventParams eventData)
             {
                 if (!eventData.parameters.ContainsKey("ama_device_id"))
-                    eventData.AddParam("ama_device_id", User.AmaDeviceId);
+                {
+                    if (!string.IsNullOrWhiteSpace(User.AmaDeviceId))
+                    {
+                        eventData.AddParam("ama_device_id", User.AmaDeviceId);    
+                    }
+                }
             }
             
             internal static bool ShouldSendEvent(EventParams eventData)
@@ -715,10 +719,13 @@ namespace Amanotes.Core
                 {
                     sb.Append(eventNameToSend);
                     sb.Append("\t");
-                    for (var i = 0; i < adapters.Count; i++)
+                    if (adapters != null && adapters.Count > 0)
                     {
-                        sb.Append(adapters[i]);
-                        if (i < adapters.Count - 1) sb.Append(",");
+                        for (var i = 0; i < adapters.Count; i++)
+                        {
+                            sb.Append(adapters[i]);
+                            if (i < adapters.Count - 1) sb.Append(",");
+                        }    
                     }
                     sb.Append("\t");
                     sb.AppendLine(eventParamsInJSON);
@@ -843,7 +850,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.IAP.cs

@@ -21,7 +21,10 @@ namespace Amanotes.Core
             public static DateTime? SubscriptionExpiredDate => localData.SubscriptionExpiredDate;
             public static DateTime? UnsubscribedDate => localData.UnsubscribedDate;
             public static readonly Dictionary<string, ProductInfo> AllProducts = new Dictionary<string, ProductInfo>();
+            
             private const string DATE_FORMAT = "yyyy/MM/yy HH:mm:ss";
+            private static readonly GDKTaskTracker<bool> _syncTaskTracker = new GDKTaskTracker<bool>();
+            private static readonly GDKTaskTracker _getProductsTaskTracker = new GDKTaskTracker();
             
             public static void SetCallback_OnModuleReady(Action onReady)
             {
@@ -37,42 +40,32 @@ namespace Amanotes.Core
                 _onModuleReady += onReady;
             }
             
-            public static void SetCallback_OnGetProductsComplete(Action onComplete)
-            {
-                if (onComplete == null) return;
-            
-                if (isGetProductComplete)
-                {
-                    onComplete();
-                    return;
-                }
-            
-                _onGetProductsComplete -= onComplete;
-                _onGetProductsComplete += onComplete;
-            }
-            
-            public static void SetCallback_OnGetCustomerInfoComplete(Action onComplete)
-            {
-                if (onComplete == null) return;
-            
-                if (isGetCustomerInfoComplete)
-                {
-                    onComplete();
-                    return;
-                }
-            
-                _onGetCustomerInfoComplete -= onComplete;
-                _onGetCustomerInfoComplete += onComplete;
-            }
-
             public static void SyncCustomerInfo(Action<bool> onComplete = null)
             {
-                if (_adapter == null)
+                if (Adapter == null)
                 {
                     onComplete?.Invoke(false);
                     return;
                 }
-                _adapter.SyncCustomerInfo(onComplete);
+
+                _syncTaskTracker.RegisterOnCompleteCallback(onComplete);
+                if (_syncTaskTracker.HasStarted) return;
+
+                _syncTaskTracker.MarkStarted();
+                Adapter.SyncCustomerInfo(getSuccess =>
+                {
+                    if (getSuccess)
+                    {
+                        localData.Sync();
+                        _syncTaskTracker.MarkCompleted(true);
+                    }
+                    else
+                    {
+                        _syncTaskTracker.MarkCompleted(false);
+                        _syncTaskTracker.Reset();
+                        LogWarning("[IAP] Fail to sync customer info. Please try again later.");
+                    }
+                });
             }
             
             public static ISetupBuilder GetProducts(bool appendExistingList = false)
@@ -181,13 +174,8 @@ namespace Amanotes.Core
                 }
             }
 
-            private static bool isGetProductComplete;
-            private static bool isGetCustomerInfoComplete;
-            private static bool IsModuleReady => isGetProductComplete && isGetCustomerInfoComplete;
-            private static Action _onGetProductsComplete;
-            private static Action _onGetCustomerInfoComplete;
+            private static bool IsModuleReady => _syncTaskTracker.HasCompleted && _getProductsTaskTracker.HasCompleted;
             private static Action _onModuleReady;
-
             internal static bool InitModule()
             {
                 _adapter = Adapter2.GetAdapter<IAPAdapter>();
@@ -199,14 +187,8 @@ namespace Amanotes.Core
             internal static void StartModule()
             {
                 if (_adapter == null) return;
-                _adapter.SyncCustomerInfo(
-                    success =>
-                    {
-                        isGetCustomerInfoComplete = true;
-                        GDKUtils.SafeInvokeAndClear(ref _onGetCustomerInfoComplete);
-                        if (IsModuleReady) GDKUtils.SafeInvokeAndClear(ref _onModuleReady);
-                    });
-                localData.Sync();
+                SyncCustomerInfo(_ => CheckModuleReady());
+                _getProductsTaskTracker.MarkStarted();
                 if (Config.iap.autoGetProducts)
                 {
                     GetProducts()
@@ -218,11 +200,15 @@ namespace Amanotes.Core
                     OnGetProductsComplete();
                 }
             }
-
+            
             private static void OnGetProductsComplete()
             {
-                isGetProductComplete = true;
-                GDKUtils.SafeInvokeAndClear(ref _onGetProductsComplete);
+                _getProductsTaskTracker.MarkCompleted();
+                CheckModuleReady();
+            }
+
+            private static void CheckModuleReady()
+            {
                 if (IsModuleReady) GDKUtils.SafeInvokeAndClear(ref _onModuleReady);
             }
         }
@@ -284,19 +270,8 @@ namespace Amanotes.Core
                     }
                 }
 
-                public void Sync()
+                internal void Sync()
                 {
-                    GDKUtils.StartCoroutine(SyncRoutine());
-                }
-
-                IEnumerator SyncRoutine()
-                {
-                    if (Adapter == null)
-                    {
-                        LogWarning("[IAP] Adapter is not available");
-                        yield break;
-                    }
-                    yield return new WaitUntil(() => Adapter.IsReady);
                     activeSubscriptionId = Adapter.GetActiveSubscriptionId();
                     subscriptionPeriodType = Adapter.GetSubscriptionPeriodType();
                     purchasedProducts = Adapter.GetPurchasedProducts();
@@ -306,7 +281,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.RemoteConfig.cs

@@ -235,7 +235,7 @@ namespace Amanotes.Core
                 }
                 
                 string filePath = GDKFileUtils.GetPath(fileName);
-                GDKFileUtils.Save(filePath, sb.ToString());
+                GDKFileUtils.Save(filePath, sb.ToString(), false);
                 GDKPool.Return(sb);
                 
                 Log($"[RemoteConfig] Saved remote config to {filePath}");

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,7 +27,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "v0.2.81-alpha.12";
+        public const string VERSION = "v0.2.81-alpha.14";
         
         internal static Status _status = Status.None;
         internal static ConfigAsset _config = null;

package/Runtime/Consent/AmaGDK.Consent.cs

@@ -76,7 +76,7 @@ namespace Amanotes.Core
                     ConsentHook.ATTRequest(isAllowed =>
                     {
                         data.att = isAllowed ? Status.Allowed : Status.NotAllowed;
-                        data.SaveJsonToFile();
+                        data.SaveJsonToFile(false);
                         onComplete?.Invoke(allowedATT);
                     });
                 }
@@ -119,7 +119,7 @@ namespace Amanotes.Core
                     {
                         data.canShowAds = canShowAd;
                         data.consentAlreadyShown = true;
-                        data.SaveJsonToFile();
+                        data.SaveJsonToFile(false);
                         onComplete?.Invoke(canShowAd);
                     }, onError);
                 }

package/Runtime/Core/GDKDebug.cs

@@ -11,7 +11,8 @@ namespace Amanotes.Core
         Warning,
         Verbose
     }
-
+    
+    #if GDK_REMOVE_STACKTRACE
     internal readonly struct NoStackTrace : IDisposable
     {
         internal readonly LogType logType;
@@ -41,10 +42,13 @@ namespace Amanotes.Core
             
         }
     }
+    #endif
     
     public class GDKDebug
     {
+        #if GDK_REMOVE_STACKTRACE
         internal static readonly IDisposable NoStackTraceNull = new NoStackTraceNull();
+        #endif
         
         public static Action<string> logNonfatalErrorHook = null;
         private static readonly HashSet<string> nonFatalDict = new HashSet<string>();
@@ -59,7 +63,9 @@ namespace Amanotes.Core
                 if (!logWarningDict.Add(key)) return;
             }
             
+            #if GDK_REMOVE_STACKTRACE
             using (GDKUtils.isOnMainThread ? NoStackTrace.Warning: NoStackTraceNull)
+            #endif
             {
                 Debug.LogWarning($"AmaGDK {message}"); 
             }
@@ -67,7 +73,9 @@ namespace Amanotes.Core
         public static void LogWarning(string message)
         {
             if (AmaGDK.logLevel < LogLevel.Warning) return;
+            #if GDK_REMOVE_STACKTRACE
             using (GDKUtils.isOnMainThread ? NoStackTrace.Warning: NoStackTraceNull)
+            #endif
             {
                 Debug.LogWarning($"AmaGDK {message}");
             }
@@ -75,7 +83,9 @@ namespace Amanotes.Core
         public static void LogError(string message)
         {
             if (AmaGDK.logLevel < LogLevel.Error) return;
+            #if GDK_REMOVE_STACKTRACE
             using (GDKUtils.isOnMainThread ? NoStackTrace.Error: NoStackTraceNull)
+            #endif
             {
                 Debug.LogError($"AmaGDK {message}");
             }
@@ -100,7 +110,9 @@ namespace Amanotes.Core
         public static void Log(string message)
         {
             if (AmaGDK.logLevel < LogLevel.Verbose) return;
+            #if GDK_REMOVE_STACKTRACE
             using (GDKUtils.isOnMainThread ? NoStackTrace.Log: NoStackTraceNull)
+            #endif
             {
                 Debug.Log($"AmaGDK {message}");   
             }
@@ -108,7 +120,9 @@ namespace Amanotes.Core
         
         public static void ForceLog(string message)
         {
+            #if GDK_REMOVE_STACKTRACE
             using (GDKUtils.isOnMainThread ? NoStackTrace.Log: NoStackTraceNull)
+            #endif
             {
                 Debug.Log($"AmaGDK {message}");
             }

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -200,7 +200,7 @@ namespace Amanotes.Core.Internal
             return GDKFileUtils.LoadJsonFromFile(instance);
         }
 
-        internal static void SaveJsonToFile<T>(this T instance, bool immediately = true) where T: IJsonFile
+        internal static void SaveJsonToFile<T>(this T instance, bool immediately) where T: IJsonFile
         {
             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(false);
                 isDirty = false;
             }
         }

package/Runtime/Utils/GDKFileUtils.cs

@@ -1,6 +1,11 @@
+// #define GDK_DEBUG_FILE_IO
+
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.Networking;
@@ -11,64 +16,145 @@ namespace Amanotes.Core.Internal
     public static class GDKFileUtils
     {
         private static string _basePath;
+        private static readonly ConcurrentDictionary<string, string> _pendingWrites =
+            new ConcurrentDictionary<string, string>();
+        private static readonly List<KeyValuePair<string, string>> _itemsToWrite =
+            new List<KeyValuePair<string, string>>(8);
+
+        private static readonly object _fileLock = new object();
+        private static int _isProcessing = 0;
+
         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);
+                try
+                {
+                    if (!Directory.Exists(_basePath))
+                    {
+                        Directory.CreateDirectory(_basePath);
+                    }
+                } catch (Exception ex)
+                {
+                    LogError($"[GDKFileUtils] Failed to create directory: {ex.Message}");
+                    _basePath = Application.persistentDataPath;
+                }
+
                 return _basePath;
             }
         }
-        
+
         internal static string GetPath(string fileName)
         {
-            return Path.Combine(basePath, fileName);
+            if (string.IsNullOrEmpty(fileName)) return null;
+            return Path.Combine(basePath, Path.GetFileName(fileName));
         }
 
         internal static bool Exist(string fileName)
         {
-            return File.Exists(GetPath(fileName));
+            if (string.IsNullOrEmpty(fileName)) return false;
+
+            string path = GetPath(fileName);
+            if (string.IsNullOrEmpty(path)) return false;
+
+            lock (_fileLock)
+            {
+                return File.Exists(path);
+            }
+        }
+
+        internal static int writePendingCount => _pendingWrites.Count;
+        internal static bool HasAnyWritePending => _pendingWrites.Count > 0;
+        internal static bool IsWritePending(string fileName)
+        {
+            return !string.IsNullOrEmpty(fileName) && _pendingWrites.ContainsKey(fileName);
         }
-        
-        public static void Save(string fileName, string content, bool immediately = true)
+
+        public static void Save(string fileName, string content, bool immediately)
         {
-            if (string.IsNullOrWhiteSpace(fileName))
+            if (string.IsNullOrEmpty(fileName)) return;
+
+            if (immediately)
             {
-                LogWarningOnce("File name must be not null or empty");
+                _pendingWrites.TryRemove(fileName, out _);
+                WriteFileDirectly(fileName, content);
                 return;
             }
 
-            if (string.IsNullOrWhiteSpace(content))
+            // Just replace any existing content
+            _pendingWrites[fileName] = content;
+
+            // Use atomic CompareExchange to ensure only one Task runs at a time
+            CheckSpawnThread();
+        }
+
+        private static void CheckSpawnThread()
+        {
+            if (Interlocked.CompareExchange(ref _isProcessing, 1, 0) == 0)
             {
-                LogWarningOnce($"Content for {fileName} is empty");
+                Task.Factory.StartNew(ProcessWriteQueue, TaskCreationOptions.None);
             }
-            
-            ThreadWrite(fileName, content, immediately);
         }
 
-        private static void ThreadWrite(string fileName, string content, bool immediately)
+        private static void ProcessWriteQueue()
         {
-            // Only write on main thread if immediately is true
-            if (!immediately && GDKUtils.isOnMainThread)
+            try
             {
-                Task.Run(()=>ThreadWrite(fileName, content, true))
-                    .ConfigureAwait(false);
-                return;
+                // var w = Stopwatch.StartNew();
+                while (!_pendingWrites.IsEmpty)
+                {
+                    // Blocking delay so batching actually occurs
+                    // In this case, it's actually better than await Task.Delay(500), why?
+                    Thread.Sleep(500);
+                
+                    _itemsToWrite.Clear();
+                    _itemsToWrite.AddRange(_pendingWrites);
+                    _pendingWrites.Clear();
+                
+                    lock (_fileLock)
+                    {
+                        foreach (var kvp in _itemsToWrite)
+                        {
+                            WriteFileDirectly(kvp.Key, kvp.Value);
+                        }
+                    }
+                }
+                
+                // w.Stop();
+                // LogWarning($"Process time: {w.ElapsedTicks} ticks | {w.ElapsedMilliseconds} milliseconds");
+            }
+            catch (Exception e)
+            {
+                LogError($"[GDKFileUtils] Write queue error: {e.Message}");
+            } finally
+            {
+                Interlocked.Exchange(ref _isProcessing, 0);
+                if (!_pendingWrites.IsEmpty) CheckSpawnThread(); // until next time!
             }
+        }
+
+        // Write directly to file without temp files
+        private static void WriteFileDirectly(string fileName, string content)
+        {
+            if (string.IsNullOrEmpty(fileName)) return;
             
             string filePath = GetPath(fileName);
-            try
+            if (string.IsNullOrEmpty(filePath)) return;
+            
+            // Lock only for the duration of actual I/O
+            lock (_fileLock)
             {
                 File.WriteAllText(filePath, content);
-            }
-            catch (Exception ex)
-            {
-                LogWarningOnce($"Exception in ThreadWrite(): {filePath}\n{ex}");
+                
+                #if GDK_DEBUG_FILE_IO
+                Log($"WriteFileDirectly threadId={Thread.CurrentThread.ManagedThreadId}: {fileName} -> {content}");
+                #endif
             }
         }
 
@@ -76,23 +162,28 @@ namespace Amanotes.Core.Internal
         {
             if (string.IsNullOrWhiteSpace(fileName))
             {
-                LogWarningOnce("File name must be not null or empty");
+                LogWarningOnce("File name must not be null or empty");
                 return;
             }
-            
+
+            // Check if `contents` is null or empty
             if (contents == null || !contents.GetEnumerator().MoveNext())
             {
                 LogWarningOnce($"Content for {fileName} is empty");
             }
 
             string path = GetPath(fileName);
-            try
-            {
-                File.AppendAllLines(path, contents);
-            }
-            catch (Exception ex)
+
+            // Concurrency-safe write
+            lock (_fileLock)
             {
-                LogWarningOnce(path + "\n" + ex);
+                try
+                {
+                    File.AppendAllLines(path, contents);
+                } catch (Exception ex)
+                {
+                    LogWarningOnce(path + "\n" + ex);
+                }
             }
         }
 
@@ -100,147 +191,192 @@ namespace Amanotes.Core.Internal
         {
             if (string.IsNullOrWhiteSpace(fileName))
             {
-                LogWarningOnce("File name must be not null or empty");
+                LogWarningOnce("File name must not be null or empty");
                 return;
             }
 
+            // Check if `content` is null or empty
             if (string.IsNullOrWhiteSpace(content))
             {
                 LogWarningOnce($"Content for {fileName} is empty");
             }
 
             string path = GetPath(fileName);
-            try
-            {
-                File.AppendAllText(path, content);
-            }
-            catch (Exception ex)
+
+            // Concurrency-safe write
+            lock (_fileLock)
             {
-                LogWarningOnce(path + "\n" + ex);
+                try
+                {
+                    File.AppendAllText(path, content);
+                } catch (Exception ex)
+                {
+                    LogWarningOnce(path + "\n" + ex);
+                }
             }
         }
 
         public static string Load(string fileName)
         {
-            var content = "";
+            if (string.IsNullOrEmpty(fileName)) return string.Empty;
 
-            if (string.IsNullOrWhiteSpace(fileName))
+            // If there's a pending in-memory write, return that content first
+            if (_pendingWrites.TryGetValue(fileName, out var inMemoryContent))
             {
-                LogWarningOnce("File name must be not null or empty");
-                return content;
+                return inMemoryContent;
             }
 
             string path = GetPath(fileName);
-            if (!File.Exists(path)) return content;
+            if (string.IsNullOrEmpty(path)) return string.Empty;
 
-            try
-            {
-                content = File.ReadAllText(path);
-            }
-            catch (Exception ex)
+            lock (_fileLock)
             {
-                LogWarningOnce(path + "\n" + ex);
+                try
+                {
+                    return !File.Exists(path) ? string.Empty : File.ReadAllText(path);
+                } catch (Exception ex)
+                {
+                    LogError($"[GDKFileUtils] Failed to read {fileName}: {ex.Message}");
+                    return string.Empty;
+                }
             }
-
-            return content;
         }
 
         public static async Task<string> LoadFromStreamingAssets(string fileName)
         {
+            if (string.IsNullOrEmpty(fileName)) return null;
             string filePath = Path.Combine(Application.streamingAssetsPath, fileName);
 
-            // Android
             if (Application.platform == RuntimePlatform.Android)
             {
-                using (UnityWebRequest request = UnityWebRequest.Get(filePath))
+                using (var request = UnityWebRequest.Get(filePath))
                 {
-                    var operation = request.SendWebRequest();
-                    while (!operation.isDone)
+                    try
                     {
-                        await Task.Yield();
-                    }
-                    if (request.result != UnityWebRequest.Result.Success)
+                        var operation = request.SendWebRequest();
+                        while (!operation.isDone)
+                        {
+                            await Task.Yield();
+                        }
+
+                        return request.result != UnityWebRequest.Result.Success
+                            ? null
+                            : request.downloadHandler.text;
+                    } catch (Exception ex)
                     {
-                        LogWarning($"Error reading file: {request.error}");
+                        LogError($"[GDKFileUtils] StreamingAssets load error: {ex.Message}");
                         return null;
                     }
-                    return request.downloadHandler.text;
                 }
             }
 
-            // Other
-            try
-            {
-                return File.ReadAllText(filePath);
-            }
-            catch (Exception e)
+            lock (_fileLock)
             {
-                LogWarning($"Error reading file: {e.Message}");
+                try
+                {
+                    return File.ReadAllText(filePath);
+                } catch (Exception ex)
+                {
+                    LogError($"[GDKFileUtils] StreamingAssets load error: {ex.Message}");
+                    return null;
+                }
             }
-            return null;
         }
 
-
         internal static void Delete(string fileName)
         {
+            if (string.IsNullOrEmpty(fileName)) return;
+            
+            _pendingWrites.TryRemove(fileName, out _);
+
             string path = GetPath(fileName);
-            if (!File.Exists(path)) return;
+            if (string.IsNullOrEmpty(path)) return;
 
-            try
+            lock (_fileLock)
             {
-                File.Delete(path);
-            }
-            catch (Exception ex)
-            {
-                LogWarningOnce(path + "\n" + ex);
+                try
+                {
+                    if (File.Exists(path))
+                    {
+                        File.Delete(path);
+                    }
+                } catch (Exception ex)
+                {
+                    LogError($"[GDKFileUtils] Delete error: {ex.Message}");
+                }
             }
         }
-        
+
         public static void ClearCacheData()
         {
-            var sb = GDKPool.GetStringBuilder();
-            sb.AppendLine("[AmaGDK] All cached data & stats cleared");
+            _pendingWrites.Clear();
+
+            if (!Directory.Exists(basePath)) return;
             
-            if (!Directory.Exists(basePath))
+            lock (_fileLock)
             {
-                sb.AppendLine("Cache path not exists: " + basePath);
-                return;
+                foreach (string file in Directory.GetFiles(basePath))
+                {
+                    try
+                    {
+                        File.Delete(file);
+                    } catch (Exception ex)
+                    {
+                        LogWarning($"[GDKFileUtils] Failed to delete {file}: {ex.Message}");
+                    }
+                }
             }
-            
-            string[] filePaths = Directory.GetFiles(basePath);
-            foreach (string path in filePaths)
+        }
+
+        // Synchronously flush everything
+        public static void Shutdown()
+        {
+            // Write out all pending items directly
+            foreach (var kvp in _pendingWrites)
             {
-                Delete(path);
-                sb.AppendLine($"[deleted] - {path}");
+                try
+                {
+                    WriteFileDirectly(kvp.Key, kvp.Value);
+                } catch (Exception ex)
+                {
+                    LogError($"[GDKFileUtils] Shutdown write error: {ex.Message}");
+                }
             }
-            Debug.Log(sb);
+
+            _pendingWrites.Clear();
         }
-        
-        public static T LoadJsonFromFile<T>(T instance) where T: new()
+
+        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
             {
-                try
+                string json = Load(instance.GetType().Name);
+                if (!string.IsNullOrEmpty(json))
                 {
                     JsonUtility.FromJsonOverwrite(json, instance);
-                } catch (Exception e)
-                {
-                    LogWarning("LoadJsonFromFile error: " + fileName + "\n" + e);
                 }
+            } catch (Exception ex)
+            {
+                LogError($"[GDKFileUtils] JSON load error: {ex.Message}");
             }
-            
+
             return instance;
         }
-        
-        public static void SaveJsonToFile<T>(T instance, bool immediately = true)
+
+        public static void SaveJsonToFile<T>(T instance, bool immediately)
         {
-            string fileName = instance.GetType().Name;
-            string json = JsonUtility.ToJson(instance);
-            ThreadWrite(fileName, json, immediately);
+            if (instance == null) return;
+
+            try
+            {
+                string json = JsonUtility.ToJson(instance);
+                Save(instance.GetType().Name, json, immediately);
+            } catch (Exception ex)
+            {
+                LogError($"[GDKFileUtils] JSON save error: {ex.Message}");
+            }
         }
     }
 }

package/Runtime/Utils/GDKUtils.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using UnityEngine;
 using static Amanotes.Core.GDKDebug;
 
@@ -96,5 +97,37 @@ namespace Amanotes.Core.Internal
             
             LogWarning(message);
         }
+        
+        public static IEnumerator WaitForSecondsRealtime(float duration, bool focusOnly = true)
+        {
+            if (!focusOnly)
+            {
+                yield return new WaitForSecondsRealtime(duration);
+                yield break;
+            }
+            float elapsedTime = 0f;
+            float lastTimeStamp = Time.realtimeSinceStartup;
+            bool focusChangedSinceLastFrame = false;
+            Action<bool> onApplicationFocusCallback = _ => focusChangedSinceLastFrame = true;
+            Application.focusChanged += onApplicationFocusCallback;
+            
+            while (elapsedTime < duration)
+            {
+                if (Application.isFocused)
+                {
+                    if (focusChangedSinceLastFrame)
+                    {
+                        lastTimeStamp = Time.realtimeSinceStartup;
+                        focusChangedSinceLastFrame = false;
+                    }
+                    
+                    elapsedTime += Time.realtimeSinceStartup - lastTimeStamp;
+                    lastTimeStamp = Time.realtimeSinceStartup;
+                }
+                
+                yield return null;
+            }
+            Application.focusChanged -= onApplicationFocusCallback;
+        }
     }
 }

package/package.json

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