com.amanotes.gdk 0.2.71 → 0.2.73-1

package/Runtime/AnalyticQualityAsset.cs

@@ -4,8 +4,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using UnityEngine;
-using UnityEngine.Assertions;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
@@ -84,11 +83,11 @@ namespace Amanotes.Core
 
         internal void ValidateParams(string eventName, Dictionary<string, object> eventParams)
         {
-            var logBuilder = GDKPool.TakeStringBuilder();
+            var logBuilder = GDKPool.GetStringBuilder();
             
             logBuilder.AppendLine($"Analytics quality violation found for event <{eventName}>");
             var isValid = true;
-            HashSet<string> checkedParameters = GDKPool.TakeHashSet();
+            HashSet<string> checkedParameters = GDKPool.GetHashSet();
 
             foreach (var kvp in DicParam)
             {
@@ -183,7 +182,7 @@ namespace Amanotes.Core
         [ContextMenu("Validate Unique EventNames")]
         private void ValidateUniqueEventNames()
         {
-            HashSet<string> eventNames = GDKPool.TakeHashSet();
+            HashSet<string> eventNames = GDKPool.GetHashSet();
             
             lstEvent = lstEvent.OrderBy(evt => evt.eventName).ToList();
             
@@ -193,7 +192,7 @@ namespace Amanotes.Core
 
                 if (!eventNames.Add(eventQuality.eventName)) Debug.LogWarning($"Duplicate event name found: {eventQuality.eventName}. Event names must be unique.");
 
-                HashSet<string> paramNames = GDKPool.TakeHashSet();
+                HashSet<string> paramNames = GDKPool.GetHashSet();
                 
                 eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
                 

package/Runtime/AudioToolkit/AmaGDK.Audio.cs

@@ -1,6 +1,7 @@
 using UnityEngine;
 using System;
 using Amanotes.Core.Internal;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core.Internal
 {
@@ -69,7 +70,7 @@ namespace Amanotes.Core
 
                 if (onAudioDeviceChange == null)
                 {
-                    Logging.LogWarning("Cannot add a null callback!");
+                    LogWarning("Cannot add a null callback!");
                     return;
                 }
 
@@ -111,7 +112,7 @@ namespace Amanotes.Core
             {
                 if (_audioDeviceDetector == null)
                 {
-                    Logging.LogWarning("AmaGDK | [Audio] Module has not been initialized!");
+                    LogWarning("AmaGDK | [Audio] Module has not been initialized!");
                     return NO_DEVICE;
                 }
 

package/Runtime/AudioToolkit/Plugins/AudioDeviceDetector.cs

@@ -176,7 +176,7 @@ namespace Amanotes.Core
                 {
                     if (sb == null)
                     {
-                        sb = GDKPool.TakeStringBuilder();
+                        sb = GDKPool.GetStringBuilder();
                         sb.Append(str, 0, i);
                     }
                     
@@ -194,7 +194,7 @@ namespace Amanotes.Core
                 }
             }
             
-            return sb == null ? str : GDKPool.ReturnAndStringify(sb);
+            return sb == null ? str : GDKPool.ReturnString(sb);
         }
     }
 

package/Runtime/Core/GDKDebug.cs

@@ -0,0 +1,97 @@
+using Amanotes.Core.Internal;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+namespace Amanotes.Core
+{
+    public enum LogLevel
+    {
+        None,
+        Error,
+        Warning,
+        Verbose
+    }
+
+    internal struct NoStackTrace : IDisposable
+    {
+        internal LogType logType;
+        internal StackTraceLogType stackTraceType;
+
+        internal NoStackTrace(LogType logType)
+        {
+            this.logType = logType;
+            stackTraceType = Application.GetStackTraceLogType(logType);
+            Application.SetStackTraceLogType(logType, StackTraceLogType.None);
+        }
+        
+        public void Dispose()
+        {
+            Application.SetStackTraceLogType(logType, stackTraceType);
+        }
+
+        public static NoStackTrace Error => new NoStackTrace(LogType.Error);
+        public static NoStackTrace Warning => new NoStackTrace(LogType.Warning);
+        public static NoStackTrace Log => new NoStackTrace(LogType.Log);
+    }
+    
+    public class GDKDebug
+    {
+        public static LogLevel logLevel;
+        public static Action<string> logNonfatalErrorHook = null;
+        private static readonly HashSet<string> nonFatalDict = new HashSet<string>();
+        public static readonly HashSet<string> logWarningDict = new HashSet<string>();
+        
+        public static void LogWarningOnce(string message, string key = null)
+        {
+            if (logLevel < LogLevel.Warning) return;
+            if (string.IsNullOrEmpty(key)) key = message;
+            if (!logWarningDict.Add(key)) return;
+            
+            using (NoStackTrace.Warning)
+            {
+                Debug.LogWarning($"AmaGDK {message}"); 
+            }
+        }
+        public static void LogWarning(string message)
+        {
+            if (logLevel < LogLevel.Warning) return;
+            using (NoStackTrace.Warning)
+            {
+                Debug.LogWarning($"AmaGDK {message}"); 
+            }
+        }
+        public static void LogError(string message)
+        {
+            if (logLevel < LogLevel.Error) return;
+            using (NoStackTrace.Error)
+            {
+                Debug.LogError($"AmaGDK {message}");    
+            }
+            
+            if (logNonfatalErrorHook == null) return;
+            GDKUtils.DoOnMainThread(() =>
+            {
+                if (!nonFatalDict.Add(message)) return; // LogOnce
+                logNonfatalErrorHook(message);
+            });
+        }
+        
+        public static void Log(string message)
+        {
+            if (logLevel < LogLevel.Verbose) return;
+            using (NoStackTrace.Log)
+            {
+                Debug.Log($"AmaGDK {message}");   
+            }
+        }
+        
+        public static void ForceLog(string message)
+        {
+            using (NoStackTrace.Log)
+            {
+                Debug.Log($"AmaGDK {message}");
+            }
+        }
+    }
+}
+

package/Runtime/Core/GDKDebug.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 952f1023aed84e35b18d0be8ae20dda9
+timeCreated: 1724669802

package/Runtime/Core/GDKPool.cs

@@ -1,385 +1,104 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Reflection;
 using System.Text;
-using Unity.Collections.LowLevel.Unsafe;
-using UnityEngine;
-using UnityEngine.Assertions;
-using UnityEngine.Profiling;
+
+using static Amanotes.Core.GDKDebug;
 namespace Amanotes.Core.Internal
 {
-    internal static class GDKPoolExtension
+    public interface IPoolItem
     {
-        internal static T Pop<T>(this List<T> list)
-        {
-            if (list == null || list.Count == 0) return default;
-
-            T result = list[list.Count - 1];
-            list.RemoveAt(list.Count - 1);
-            return result;
-        }
-    }
-
-    public static partial class GDKPool // TypeHandler 
-    {
-        private const int STRING_BUILDER_DEFAULT_LEN = 64;
-        private static readonly Dictionary<Type, object> typeHandlerMap = new Dictionary<Type, object>
-        {
-            { typeof(StringBuilder), new TypeHandler<StringBuilder>(() => new StringBuilder(), h => h.Clear()) },
-            { typeof(HashSet<string>), new TypeHandler<HashSet<string>>(() => new HashSet<string>(), h => h.Clear()) },
-            { typeof(Dictionary<string, object>), new TypeHandler<Dictionary<string, object>>(() => new Dictionary<string, object>(), d => d.Clear()) }
-        };
-
-        public static TypeHandler<T> GetTypeHandler<T>() where T : class
-        {
-            return typeHandlerMap.TryGetValue(typeof(T), out object result)
-                ? UnsafeUtility.As<object, TypeHandler<T>>(ref result)
-                : null;
-        }
-
-        public static TypeHandler<T> AddTypeHandler<T>(Func<T> newT, Action<T> resetT = null) where T : class
-        {
-            if (typeof(IPoolItem).IsAssignableFrom(typeof(T)))
-            {
-                if (resetT != null) Debug.LogWarning("Unsupported custom resetT() when T: IPoolItem!");
-                resetT = item => { (item as IPoolItem)?.Reset(); };
-            }
-
-            var result = new TypeHandler<T>(newT, resetT);
-            typeHandlerMap.Add(typeof(T), result);
-            return result;
-        }
-        public static TypeHandler<T> AddTypeHandler<T>(Action<T> resetT = null) where T : class, new()
-        {
-            return AddTypeHandler(() => new T(), resetT);
-        }
-        public class TypeHandler<T> where T : class
-        {
-            public readonly Func<T> newT;
-            public readonly Action<T> resetT;
-
-            public TypeHandler(Func<T> newT, Action<T> resetT)
-            {
-                this.newT = newT;
-                this.resetT = resetT;
-            }
-        }
+        void Reset();
     }
 
-    public static partial class GDKPool // Interface 
-    {
-        public interface IPoolItem
-        {
-            void Reset();
-        }
-        public interface IPool<T> where T : class
-        {
-            int Count { get; } // Added to get the number of items currently in the pool
-            T Take();
-            void Return(T item);
-        }
-        public interface IPoolMap
-        {
-            IPool<T> GetPool<T>() where T : class;
-            IPool<T> CreatePool<T>(TypeHandler<T> handler = null) where T : class;
-            IPool<T> GetOrCreatePool<T>(TypeHandler<T> handler = null) where T : class;
-        }
-    }
-    public static partial class GDKPool // POOLs 
+    public static class GDKPool
     {
-        internal abstract class BasePool<T, T1> : IPool<T>
-            where T : class
-            where T1 : new()
+        internal class Pool<T> where T : new()
         {
-            internal readonly TypeHandler<T> handler;
-            internal readonly T1 pool;
-            protected BasePool(TypeHandler<T> handler)
+            private readonly ConcurrentQueue<T> _pool;
+            public Pool(int initialCapacity = 4)
             {
-                pool = new T1();
-                this.handler = handler;
-            }
-
-            public abstract T Take();
-            public abstract void Return(T item);
-            public abstract int Count { get; }
-        }
-        internal sealed class ListPool<T> : BasePool<T, List<T>> where T : class
-        {
-            public ListPool(TypeHandler<T> handler, int capacity) : base(handler)
-            {
-                for (var i = 0; i < capacity; i++)
+                _pool = new ConcurrentQueue<T>();
+                for (var i = 0; i < initialCapacity; i++)
                 {
-                    Return(handler.newT());
+                    _pool.Enqueue(new T());
                 }
             }
-            public override int Count => pool.Count;
-
-            public override T Take()
-            {
-                if (pool.Count == 0) return handler.newT();
-                T last = pool.Pop();
-                handler.resetT?.Invoke(last); // Take from pool: Do Reset
-                return last;
-            }
-
-            internal T TakeAt(int idx)
-            {
-                if (idx < 0 || idx >= pool.Count - 1) return Take();
-
-                // swap last item to index
-                T item = pool[idx];
-                pool[idx] = pool.Pop();
-                handler.resetT?.Invoke(item);
-                return item;
-            }
-
-            public override void Return(T item)
-            {
-                if (item == null) return;
-                pool.Add(item);
-            }
-        }
-        internal sealed class ConcurrentPool<T> : BasePool<T, ConcurrentBag<T>> where T : class
-        {
-            public ConcurrentPool(TypeHandler<T> handler, int capacity) : base(handler)
+        
+            public Pool(int initialCapacity, Func<T> newT)
             {
-                for (var i = 0; i < capacity; i++)
+                _pool = new ConcurrentQueue<T>();
+                for (var i = 0; i < initialCapacity; i++)
                 {
-                    Return(handler.newT());
+                    _pool.Enqueue(newT());
                 }
             }
-
-            public override int Count => pool.Count;
-
-            public override T Take()
-            {
-                if (!pool.TryTake(out T result)) return handler.newT();
-                handler.resetT?.Invoke(result);
-                return result;
-            }
-
-            public override void Return(T item)
-            {
-                if (item == null) return;
-                pool.Add(item);
-            }
-        }
-    }
-
-    public static partial class GDKPool // POOL MAP 
-    {
-        internal abstract class BasePoolMap<TDict> : IPoolMap where TDict : IDictionary<Type, object>, new()
-        {
-            internal readonly TDict map = new TDict();
-
-            // IPoolMap
-            public IPool<T> GetPool<T>() where T : class
-            {
-                return map.TryGetValue(typeof(T), out object result)
-                    ? UnsafeUtility.As<object, IPool<T>>(ref result)
-                    : null;
-            }
-
-            public IPool<T> CreatePool<T>(TypeHandler<T> handler = null) where T : class
+        
+            public T Get()
             {
-                return CreatePoolInternal(handler ?? GetTypeHandler<T>());
+                if (!_pool.TryDequeue(out var obj)) return new T();
+                if (obj is IPoolItem poolItem) poolItem.Reset();
+                return obj;
             }
 
-            public IPool<T> GetOrCreatePool<T>(TypeHandler<T> handler = null) where T : class
+            public void Return(T obj)
             {
-                return GetPool<T>() ?? CreatePoolInternal(handler ?? GetTypeHandler<T>());
+                _pool.Enqueue(obj);
             }
-            internal abstract IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class;
-        }
-        internal class ListPoolMap : BasePoolMap<Dictionary<Type, object>>
-        {
-            internal override IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class
-            {
-                var result = new ListPool<T>(handler, 1);
-                map.Add(typeof(T), result);
-                return result;
-            }
-        }
-        internal class ConcurrentPoolMap : BasePoolMap<ConcurrentDictionary<Type, object>>
-        {
-            internal override IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class
-            {
-                var result = new ConcurrentPool<T>(handler, 1);
-                map.TryAdd(typeof(T), result);
-                return result;
-            }
-        }
-    }
-
-    public static partial class GDKPool
-    {
-        private static readonly ListPoolMap mainPM = new ListPoolMap();
-        private static readonly ConcurrentPoolMap threadPM = new ConcurrentPoolMap();
-
-        // HashSet<T> support
-        private static readonly ListPool<HashSet<string>> hPool; // cached reference for main-thread
-        private static readonly ListPool<StringBuilder> sbPool;
-
-        // StringBuilder support
-        private static readonly ListPool<StringBuilder> fixedSBPool;
-
-        // Dictionary support
-        private static readonly ListPool<Dictionary<string, object>> dictPool;
 
-        // SPECIAL APIs
-        static GDKPool()
-        {
-            // Main-thread: Use fixed-length StringBuilder
-            sbPool = (ListPool<StringBuilder>) mainPM.CreatePool<StringBuilder>();
-            hPool = (ListPool<HashSet<string>>) mainPM.CreatePool<HashSet<string>>();
-            dictPool = (ListPool<Dictionary<string, object>>)mainPM.CreatePool<Dictionary<string, object>>();
-            fixedSBPool = new ListPool<StringBuilder>(new TypeHandler<StringBuilder>(null, sb => sb.Clear()), 0);
+            public int Count => _pool.Count;
         }
+        private static readonly Pool<StringBuilder> sbPool1KB = new Pool<StringBuilder>(8, () => new StringBuilder(1024));
+        private static readonly Pool<StringBuilder> sbPool8KB = new Pool<StringBuilder>(8, () => new StringBuilder(8*1024));
+        private static readonly Pool<HashSet<string>> hashsetPool = new Pool<HashSet<string>>(4);
         
-        private static IPoolMap poolMap => GDKUtils.isOnMainThread ? mainPM : (IPoolMap)threadPM;
-        internal static void ClearAndReset()
+        public static StringBuilder GetStringBuilder(int capacityInKb = 1)
         {
-            // main thread
-            mainPM.map.Clear();
-            mainPM.map.Add(typeof(StringBuilder), sbPool);
-            mainPM.map.Add(typeof(HashSet<string>), hPool);
-            mainPM.map.Add(typeof(Dictionary<string, object>), dictPool);
-            
-            // other threads
-            threadPM.map.Clear();
+            StringBuilder result = capacityInKb <= 1 ? sbPool1KB.Get() : sbPool8KB.Get();
+            result.Clear();
+            return result;
         }
-
-        public static T Take<T>(bool autoCreatePool = true) where T : class, new()
+        
+        public static HashSet<string> GetHashSet()
         {
-            IPool<T> pool = poolMap.GetPool<T>() ?? CreatePool<T>();
-            return pool.Take();
+            HashSet<string> result = hashsetPool.Get();
+            result.Clear();
+            return result;
         }
         
-        public static T Take<T>(Action<T> resetT) where T : class, new()
+        public static string ReturnString(StringBuilder sb)
         {
-            IPool<T> pool = poolMap.GetPool<T>() ?? CreatePool(() => new T(), resetT);
-            return pool.Take();
+            if (sb == null) return null;
+            var result = sb.ToString();
+            Return(sb);
+            return result;
         }
         
-        public static void Return<T>(T item) where T : class
+        public static void Return(StringBuilder sb)
         {
-            if (typeof(T) == typeof(StringBuilder))
+            if (sb == null) return;
+            int capacity = sb.Capacity;
+            
+            if (capacity == 1024)
             {
-                StringBuilder sb = UnsafeUtility.As<T, StringBuilder>(ref item);
-                if (sb.Capacity == sb.MaxCapacity)
-                {
-                    fixedSBPool.Return(sb);
-                    return;
-                }
+                sbPool1KB.Return(sb);
+                return;
             }
             
-            poolMap.GetPool<T>()?.Return(item);
-        }
-
-        public static IPool<T> GetPool<T>(bool autoCreatePool = false) where T : class, new()
-        {
-            IPool<T> result = poolMap.GetPool<T>();
-            if (result != null) return result;
-            return autoCreatePool ? CreatePool<T>() : null;
-        }
-        private static IPool<T> TryCreatePoolUsingTypeHandler<T>() where T : class
-        {
-            TypeHandler<T> handler = GetTypeHandler<T>();
-            return handler != null ? poolMap.CreatePool(handler) : null;
+            sbPool8KB.Return(sb);
         }
-        public static IPool<T> CreatePool<T>(Func<T> newT, Action<T> resetT) where T : class
-        {
-            IPool<T> result = TryCreatePoolUsingTypeHandler<T>();
-            if (result != null) return result;
-            return poolMap.CreatePool(AddTypeHandler(newT, resetT));
-        }
-
-        public static IPool<T> CreatePool<T>(Action<T> resetT = null) where T : class, new()
-        {
-            IPool<T> result = TryCreatePoolUsingTypeHandler<T>();
-            if (result != null) return result;
-            return poolMap.CreatePool(AddTypeHandler(() => new T(), resetT));
-        }
-        public static HashSet<T> TakeHashSet<T>()
-        {
-            var result = Take<HashSet<T>>();
-            return result ?? CreatePool<HashSet<T>>(h => h.Clear()).Take();
-        }
-        public static HashSet<string> TakeHashSet()
+        
+        public static void Return(HashSet<string> hashset)
         {
-            return GDKUtils.isOnMainThread ? hPool.Take() : TakeHashSet<string>();
+            if (hashset == null) return;
+            hashsetPool.Return(hashset);
         }
-
+        
         public static void ReturnAndNullize(ref HashSet<string> hashset)
         {
             if (hashset == null) return;
-            hashset.Clear();
-            Return(hashset);
+            hashsetPool.Return(hashset);
             hashset = null;
         }
-
-        public static StringBuilder TakeStringBuilder(int fixedLength = 0)
-        {
-            if (!GDKUtils.isOnMainThread)
-            {
-                if (fixedLength != 0) Logging.LogWarningOnce("Fixed length StringBuilder only work for Main Thread!");
-                return Take<StringBuilder>();
-            }
-            
-            if (fixedLength == 0) return Take<StringBuilder>();
-            
-            if (fixedSBPool.Count == 0) return new StringBuilder(fixedLength, fixedLength);
-            List<StringBuilder> pool = fixedSBPool.pool;
-            for (var i = 0; i < pool.Count; i++)
-            {
-                if (pool[i].Capacity != fixedLength) continue;
-                return fixedSBPool.TakeAt(i);
-            }
-            
-            return new StringBuilder(fixedLength, fixedLength);
-        }
-
-        private static FieldInfo sbStringValueField;
-        private static readonly Dictionary<StringBuilder, string> internalSB = new Dictionary<StringBuilder, string>();
-        public static string ReturnAndStringify(StringBuilder sb)
-        {
-            if (sb == null) return null;
-            
-            // if (GDKUtils.isOnMainThread && sb.Capacity == sb.MaxCapacity)
-            // {
-            //     string str;
-            //     Profiler.BeginSample("GDKPool.ReturnAndStringify()");
-            //     {
-            //         if (!internalSB.TryGetValue(sb, out str))
-            //         {
-            //             sbStringValueField ??= typeof(StringBuilder)
-            //                 .GetField("m_StringValue", BindingFlags.NonPublic | BindingFlags.Instance);
-            //             
-            //             str = (string)sbStringValueField?.GetValue(sb);
-            //             internalSB.Add(sb, str);
-            //         }
-            //         
-            //         fixedSBPool.Return(sb);
-            //     }
-            //     Profiler.EndSample();
-            //     return str;
-            // }
-            
-            string result = null;
-            Profiler.BeginSample("GDKPool.ReturnAndStringify()");
-            {
-                result = sb.ToString();
-                sb.Clear();
-                Return(sb);
-            }
-            Profiler.EndSample();
-
-            return result;
-        }
-        public static Dictionary<string, object> TakeDictionary()
-        {
-            return GDKUtils.isOnMainThread ? dictPool.Take() : Take<Dictionary<string, object>>();
-        }
     }
 }

package/Runtime/Core/GDKRoutine.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections;
 using UnityEngine;
+using static Amanotes.Core.GDKDebug;
+
 namespace Amanotes.Core.Internal
 {
     public class GDKRoutine
@@ -59,7 +61,7 @@ namespace Amanotes.Core.Internal
                 } catch (Exception ex)
                 {
                     status |= RoutineStatus.Stopped;
-                    if (exceptionHandler == null) Logging.LogError($"Exception caught in coroutine: {ex}");
+                    if (exceptionHandler == null) LogError($"Exception caught in coroutine: {ex}");
                     exceptionHandler?.Invoke(ex);
                     yield break; // Stop executing the coroutine
                 }

package/Runtime/Core/GDKSemVer.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using UnityEngine.Profiling;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core.Internal
 {