com.amanotes.gdk 0.2.81-alpha.8 → 0.2.81

package/Runtime/Core/GDKDebug.cs

@@ -11,11 +11,12 @@ namespace Amanotes.Core
         Warning,
         Verbose
     }
-
-    internal struct NoStackTrace : IDisposable
+    
+    #if GDK_REMOVE_STACKTRACE
+    internal readonly struct NoStackTrace : IDisposable
     {
-        internal LogType logType;
-        internal StackTraceLogType stackTraceType;
+        internal readonly LogType logType;
+        internal readonly StackTraceLogType stackTraceType;
 
         internal NoStackTrace(LogType logType)
         {
@@ -34,8 +35,21 @@ namespace Amanotes.Core
         public static NoStackTrace Log => new NoStackTrace(LogType.Log);
     }
     
+    internal readonly struct NoStackTraceNull: IDisposable
+    {
+        public void Dispose()
+        {
+            
+        }
+    }
+    #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>();
         private static readonly HashSet<string> logWarningDict = new HashSet<string>();
@@ -49,7 +63,9 @@ namespace Amanotes.Core
                 if (!logWarningDict.Add(key)) return;
             }
             
-            using (NoStackTrace.Warning)
+            #if GDK_REMOVE_STACKTRACE
+            using (GDKUtils.isOnMainThread ? NoStackTrace.Warning: NoStackTraceNull)
+            #endif
             {
                 Debug.LogWarning($"AmaGDK {message}"); 
             }
@@ -57,45 +73,46 @@ namespace Amanotes.Core
         public static void LogWarning(string message)
         {
             if (AmaGDK.logLevel < LogLevel.Warning) return;
-            using (NoStackTrace.Warning)
+            #if GDK_REMOVE_STACKTRACE
+            using (GDKUtils.isOnMainThread ? NoStackTrace.Warning: NoStackTraceNull)
+            #endif
             {
-                Debug.LogWarning($"AmaGDK {message}"); 
+                Debug.LogWarning($"AmaGDK {message}");
             }
         }
         public static void LogError(string message)
         {
             if (AmaGDK.logLevel < LogLevel.Error) return;
-            using (NoStackTrace.Error)
+            #if GDK_REMOVE_STACKTRACE
+            using (GDKUtils.isOnMainThread ? NoStackTrace.Error: NoStackTraceNull)
+            #endif
             {
-                Debug.LogError($"AmaGDK {message}");    
+                Debug.LogError($"AmaGDK {message}");
             }
             
             if (logNonfatalErrorHook == null) return;
             
             if (GDKUtils.isOnMainThread) // Most of the time
             {
-                lock (nonFatalDict)
-                {
-                    if (!nonFatalDict.Add(message)) return;
-                }
-                logNonfatalErrorHook(message);
+                LogNonFatalOnMainThread(message);
                 return;
             }
             
-            GDKUtils.DoOnMainThread(() =>
-            {
-                lock (nonFatalDict)
-                {
-                    if (!nonFatalDict.Add(message)) return; // LogOnce
-                }
-                logNonfatalErrorHook(message);
-            });
+            GDKUtils.DoOnMainThread(() => { LogNonFatalOnMainThread(message); });
+        }
+
+        private static void LogNonFatalOnMainThread(string message)
+        {
+            if (!nonFatalDict.Add(message)) return;
+            logNonfatalErrorHook(message);
         }
         
         public static void Log(string message)
         {
             if (AmaGDK.logLevel < LogLevel.Verbose) return;
-            using (NoStackTrace.Log)
+            #if GDK_REMOVE_STACKTRACE
+            using (GDKUtils.isOnMainThread ? NoStackTrace.Log: NoStackTraceNull)
+            #endif
             {
                 Debug.Log($"AmaGDK {message}");   
             }
@@ -103,7 +120,9 @@ namespace Amanotes.Core
         
         public static void ForceLog(string message)
         {
-            using (NoStackTrace.Log)
+            #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.8",
+    "version": "0.2.81",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",