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

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

@@ -281,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.13";
+        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/package.json

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