com.amanotes.gdk 0.2.68 → 0.2.70

package/Runtime/AmaGDK.Analytics.cs

@@ -68,8 +68,9 @@ namespace Amanotes.Core
                     doNotIncreaseCounter = false;
                     isLoggedImmediately = false;
                     overrideConfig = false;
-                    ignoreAdapterIds = null;
-                    allowAdapterIds = null;
+                    
+                    GDKPool.ReturnAndNullize(ref ignoreAdapterIds);
+                    GDKPool.ReturnAndNullize(ref allowAdapterIds);
                     _detail = null;
                 }
                 
@@ -307,9 +308,8 @@ namespace Amanotes.Core
             internal static readonly List<AnalyticsAdapter> listAdapters = new List<AnalyticsAdapter>();
             internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile().BuildCache();
             internal static SessionStat sessionStat;
-            internal static readonly GDKPool<StringBuilder> sbPool = new GDKPool<StringBuilder>(3);
-            internal static readonly GDKPool<EventParams> epPool = new GDKPool<EventParams>(1);
-
+            internal static readonly GDKPool.Pool<EventParams> epPool = new GDKPool.Pool<EventParams>(1);
+            
             internal static readonly Dictionary<string, string> reservedPrefixes = new Dictionary<string, string>()
             {
                 { "firebase_", "frb_" },
@@ -515,32 +515,31 @@ namespace Amanotes.Core
             {
                 Profiler.BeginSample("AmaGDK.Analytics.NormalizeEventName()");
                 {
-                    var sb = sbPool.Get();
-                    sb.Clear();
-                    NormalizeKeyString(ref eventName, sb, dryRun);
+                    var warningLog = GDKPool.GetStringBuilder(8);
+                    NormalizeKeyString(ref eventName, warningLog, dryRun);
                     if (reservedEvents.Contains(eventName))
-                        sb.AppendLine($" - EventName <{eventName}> is reserved and should not be used");
-                    if (sb.Length > 0 && dryRun) LogWarningOnce($"NormalizeEventName <{eventName}> warnings:\n{sb}\n", $"NormalizeEventName<{eventName}>");
-                    sbPool.Return(sb);
+                    {
+                        warningLog.AppendLine($" - EventName <{eventName}> is reserved and should not be used");
+                    }
+                    if (warningLog.Length > 0 && dryRun) LogWarningOnce($"NormalizeEventName <{eventName}> warnings:\n{warningLog}\n", $"NormalizeEventName<{eventName}>");
+                    GDKPool.Return(warningLog);
                 }
                 Profiler.EndSample();
             }
 
             internal static void NormalizeKeyString(ref string key, StringBuilder warningLog, bool dryRun)
             {
+                if (string.IsNullOrWhiteSpace(key))
+                {
+                    LogWarning($" - Name should not be empty");
+                    return;
+                }
+                
                 Profiler.BeginSample("AmaGDK.Analytics.NormalizeKeyString()");
                 {
-                    if (string.IsNullOrWhiteSpace(key))
-                    {
-                        LogWarning($" - Name should not be empty");
-                        Profiler.EndSample();
-                        return;
-                    }
-                    
-                    var tempLog = Config.common.logLevel == LogLevel.None ? null : sbPool.Get();
-                    tempLog?.Clear();
-                    var tempKey = sbPool.Get();
-                    tempKey.Clear();
+                    var willLog = Config.common.logLevel != LogLevel.None;
+                    var tempLog = willLog ? GDKPool.GetStringBuilder() : null;
+                    var tempKey = GDKPool.GetStringBuilder();
                     
                     var hasChanged = false;
                     var trimKey = key.Trim();
@@ -563,16 +562,16 @@ namespace Amanotes.Core
                         }
                     }
 
-                    if (hasChanged)
+                    if (hasChanged && willLog)
                     {
-                        tempLog?.Append(" - Name may only contain alphanumeric characters and underscores");
+                        tempLog.Append(" - Name may only contain alphanumeric characters and underscores");
                     }
                     
                     if (tempKey.Length > 0 && !IsAlphabet(tempKey[0]))
                     {
                         hasChanged = true;
                         tempKey.Insert(0, 'E');
-                        tempLog?.Append($" - Name must start with a letter: <{key}>");
+                        if (willLog) tempLog.Append($" - Name must start with a letter: <{key}>");
                     }
                     
                     foreach (var prefix in reservedPrefixes)
@@ -581,13 +580,13 @@ namespace Amanotes.Core
                         hasChanged = true;
                         tempKey.Remove(0, prefix.Key.Length);
                         tempKey.Insert(0, prefix.Value);
-                        tempLog?.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
+                        if (willLog) tempLog.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
                     }
 
                     if (trimKey.Length > 40)
                     {
                         hasChanged = true;
-                        tempLog?.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
+                        if (willLog) tempLog.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
                         tempKey.Length = 40;
                     }
                     
@@ -598,8 +597,8 @@ namespace Amanotes.Core
                         if (hasChanged) key = tempKey.ToString();
                     }
                     
-                    if (tempLog != null) sbPool.Return(tempLog);
-                    sbPool.Return(tempKey);
+                    GDKPool.Return(tempLog);
+                    GDKPool.Return(tempKey);
                 }
                 Profiler.EndSample();
             }
@@ -702,9 +701,17 @@ namespace Amanotes.Core
                     adapters = adapterIDs;
                 }
 
-                public string ToTsv()
+                public void AppendAsTSV(StringBuilder sb)
                 {
-                    return $"{eventNameToSend}\t{string.Join(",", adapters)}\t{parameters}";
+                    sb.Append(eventNameToSend);
+                    sb.Append("\t");
+                    for (var i = 0; i < adapters.Count; i++)
+                    {
+                        sb.Append(adapters[i]);
+                        if (i < adapters.Count - 1) sb.Append(",");
+                    }
+                    sb.Append("\t");
+                    sb.Append(parameters);
                 }
             }
 
@@ -856,8 +863,8 @@ namespace Amanotes.Core
             {
                 private const string TSV_HEADER_ROW = "EventName\tAdapters\tParameters";
                 private readonly string fileName = nameof(SessionStat) + DateTime.Now.ToString("_yyMMdd_HHmmss") + ".tsv";
-                private StringBuilder contents = new StringBuilder();
                 private bool isFirstSave = true;
+                private StringBuilder contents = new StringBuilder(8192);
                 private readonly ConcurrentQueue<EventStat> lastFrameEventStats = new ConcurrentQueue<EventStat>();
                 internal readonly ConcurrentQueue<EventStat> savedEventStatsInLastFrame = new ConcurrentQueue<EventStat>();
 
@@ -878,10 +885,10 @@ namespace Amanotes.Core
                     }
                     while (lastFrameEventStats.TryDequeue(out var stat))
                     {
-                        contents.AppendLine(stat.ToTsv());
+                        stat.AppendAsTSV(contents);
                         savedEventStatsInLastFrame.Enqueue(stat);
                     }
-
+                    
                     GDKFileUtils.SaveAppend(fileName, contents.ToString());
                 }
 
@@ -972,7 +979,7 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
-            eventData.ignoreAdapterIds ??= new HashSet<string>();
+            eventData.ignoreAdapterIds ??= GDKPool.GetHashSet();
             
             foreach (string mId in analyticIds)
             {
@@ -998,7 +1005,7 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
-            eventData.allowAdapterIds ??= new HashSet<string>();
+            eventData.allowAdapterIds ??= GDKPool.GetHashSet();
             
             foreach (string mId in analyticIds)
             {
@@ -1080,12 +1087,12 @@ namespace Amanotes.Core
         {
             string eventName = (ap as EventParams)?.eventName;
             
-            var sb = sbPool.Get();
+            var sb = GDKPool.GetStringBuilder();
             sb.Clear();
             NormalizeKeyString(ref key, sb, AmaGDK.Config.analytics.normalizeEventName);
             
             if (sb.Length > 0) LogWarningOnce($"Warning for event <{eventName}>, param <{key}>:\n{sb}", $"NormalizeParamKey <{eventName}>");
-            sbPool.Return(sb);
+            GDKPool.Return(sb);
             
             if (string.IsNullOrWhiteSpace(key))
             {

package/Runtime/AmaGDK.Consent.cs

@@ -0,0 +1,259 @@
+using System;
+using Amanotes.Core.Internal;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK //Consent
+    {
+        public static partial class Consent //Public
+        {
+            private static bool _onGoingRequestAllConsents;
+            public static void RequestAllConsents(Action onComplete)
+            {
+                OnAllConsentComplete(onComplete);
+                
+                if (_onGoingRequestAllConsents)
+                {
+                    Logging.LogWarning($"[Consent] RequestAllConsents is called multiple times.");
+                    return;
+                }
+                
+                _onGoingRequestAllConsents = true;
+#if UNITY_IOS
+                ATT.Request(ConsiderCMP);
+#else
+                CMP.Request(EndConsent);
+#endif
+            }
+
+            public static void OnAllConsentComplete(Action onComplete)
+            {
+                if (allConsentChecked)
+                {
+                    onComplete?.Invoke();
+                    return;
+                }
+
+                _onConsentComplete -= onComplete;
+                _onConsentComplete += onComplete;
+            }
+        }
+        
+        public static partial class Consent //ATT
+        {
+            public static class ATT
+            {
+                public static bool IsAllowed
+                {
+                    get
+                    {
+                        if (checkedATT) return allowedATT;
+                        Logging.LogWarning("[Consent] ATT has not completed yet");
+                        return false;
+                    }
+                }
+            
+                public static void Request(Action<bool> onComplete)
+                {
+                    if (checkedATT)
+                    {
+                        onComplete?.Invoke(allowedATT);
+                        return;
+                    }
+
+                    ConsentHook.ATTRequest(isAllowed =>
+                    {
+                        data.att = isAllowed ? Status.Allowed : Status.NotAllowed;
+                        data.SaveJsonToFile();
+                        onComplete?.Invoke(allowedATT);
+                    });
+                }
+            }
+            
+        }
+        
+        public static partial class Consent //CMP
+        {
+            public static class CMP
+            {
+                public static bool IsRequired
+                {
+                    get
+                    {
+                        if (checkedCMP) return data.cmp >= Status.Allowed;
+                        
+                        if (!ConsentHook.IsRequiredCMP.HasValue)
+                        {
+                            Logging.LogWarningOnce("[Consent] CMP is not available or not ready");
+                            return false;
+                        }
+    
+                        return ConsentHook.IsRequiredCMP.Value;
+                    }
+                }
+                
+                public static void Request(Action<bool> onComplete)
+                {
+                    if (checkedCMP)
+                    {
+                        onComplete?.Invoke(checkedCMP);
+                        return;
+                    }
+                    
+                    ConsentHook.TryToShowCMP(successful =>
+                    {
+                        if (successful)
+                        {
+                            data.cmp = !IsRequired ? Status.NotRequired : Status.Allowed;
+                            data.SaveJsonToFile();
+                        }
+                        onComplete?.Invoke(checkedCMP);
+                    });
+                }
+                
+                public static void ForceShowPopUp(Action onComplete)
+                {
+                    OnAllConsentComplete(onComplete);
+                    ConsentHook.ForceShowCMP(EndConsent);
+                }
+            }
+        }
+
+        public static partial class Consent //Internal
+        {
+            private static readonly ConsentData data = new ConsentData().LoadJsonFromFile();
+            private static Action _onConsentComplete;
+            
+            internal static bool checkedATT => data.att >= Status.Allowed;
+            internal static bool allowedATT => data.att == Status.Allowed;
+            internal static bool checkedCMP => data.cmp >= Status.NotRequired;
+            internal static bool allConsentChecked => checkedATT && checkedCMP;
+            
+            internal enum Status
+            {
+                None,
+                NotRequired,
+                Allowed,
+                NotAllowed
+            }
+
+            internal static bool InitModule()
+            {
+                if (allConsentChecked) return true;
+                if (!_config.consent.autoGetConsent) return true;
+                RequestAllConsents(null);
+                return true;
+            }
+
+            private static void ConsiderCMP(bool needToShowCMP)
+            {
+                if (checkedCMP)
+                {
+                    EndConsent(true);
+                    return;
+                }
+                
+                if (needToShowCMP)
+                {
+                    ConsentHook.TryToShowCMP(EndConsent);
+                }
+                else
+                {
+                    ConsentHook.SetNotRequiredCMP(EndConsent);
+                }
+            }
+
+            private static void EndConsent(bool isConsentSuccess)
+            {
+                var tmpAction = _onConsentComplete;
+                _onConsentComplete = null;
+                tmpAction?.Invoke();
+                Logging.Log("[Consent] End consent checking");
+            }
+        }
+    }
+    
+    [Serializable]
+    public class ConsentData : IJsonFile
+    {
+        [SerializeField] internal AmaGDK.Consent.Status att;
+        [SerializeField] internal AmaGDK.Consent.Status cmp;
+    }
+
+    public static class ConsentHook
+    {
+        public static bool? IsRequiredCMP;
+        
+        private static Action<Action<bool>> _tryToShowCMP;
+        public static Action<Action<bool>> TryToShowCMP
+        {
+            get
+            {
+                if (_tryToShowCMP != null) return _tryToShowCMP;
+                
+                Logging.LogWarning("[Consent] ConsentHook.TryToShowCMP is null");
+                _tryToShowCMP = callback => callback(false);
+                return _tryToShowCMP;
+            }
+            set => _tryToShowCMP = value;
+        }
+        
+        private static Action<Action<bool>> _forceShowCMP;
+        public static Action<Action<bool>> ForceShowCMP
+        {
+            get
+            {
+                if (_forceShowCMP != null) return _forceShowCMP;
+                
+                Logging.LogWarning("[Consent] ConsentHook.ForceShowCMP is null");
+                _forceShowCMP = callback => callback(false);
+                return _forceShowCMP;
+            }
+            set => _forceShowCMP = value;
+        }
+
+        private static Action<Action<bool>> _setNotRequiredCMP;
+        public static Action<Action<bool>> SetNotRequiredCMP
+        {
+            get
+            {
+                if (_setNotRequiredCMP != null) return _setNotRequiredCMP;
+                
+                Logging.LogWarning("[Consent] ConsentHook.SetNotRequiredCMP is null");
+                _setNotRequiredCMP = callback => callback(false);
+                return _setNotRequiredCMP;
+            }
+            set => _setNotRequiredCMP = value;
+        }
+
+        private static Action<Action<bool>> _attRequest;
+        public static Action<Action<bool>> ATTRequest
+        {
+            get
+            {
+                if (_attRequest != null) return _attRequest;
+                
+                Logging.LogWarning("[Consent] ConsentHook.ATTRequest is null");
+                _attRequest = callback => callback(false);
+                return _attRequest;
+            }
+            set => _attRequest = value;
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    [Serializable]
+    public class ConsentConfig
+    {
+        [Tooltip("Auto pop-up ATT and CMP form")]
+        public bool autoGetConsent = true;
+    }
+    
+    public partial class ConfigAsset
+    {
+        [SerializeField] public ConsentConfig consent;
+    }
+}

package/Runtime/AmaGDK.Consent.cs.meta

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

package/Runtime/AmaGDK.Device.cs

@@ -67,16 +67,16 @@ namespace Amanotes.Core.Internal
             
             if (AmaGDK.Config.common.logLevel == LogLevel.Verbose)
             {
-                var stringBuilder = new StringBuilder();
+                var stringBuilder = GDKPool.GetStringBuilder();
                 stringBuilder.Append("Device info:");
                 stringBuilder.AppendLine("DeviceSpec: " + result);
                 stringBuilder.AppendLine("systemMemorySize: " + SystemInfo.systemMemorySize);
                 stringBuilder.AppendLine("processorCount: " + SystemInfo.processorCount);
                 stringBuilder.AppendLine("processorFrequency: " + SystemInfo.processorFrequency);
-                stringBuilder.AppendLine("graphicsMemorySize: " + SystemInfo.graphicsMemorySize);
-                    
-                Logging.Log(stringBuilder.ToString());   
+                stringBuilder.AppendLine("graphicsMemorySize: " + SystemInfo.graphicsMemorySize);    
+                Logging.Log(GDKPool.ReturnString(stringBuilder));
             }
+            
             return result;
         }
         

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -214,7 +214,7 @@ namespace Amanotes.Core
                 Profiler.BeginSample("AmaGDK.RemoteConfig.SaveCache()");
                 
                 _fetchState = FetchState.SaveCache;
-                StringBuilder sb = new StringBuilder();
+                StringBuilder sb = GDKPool.GetStringBuilder(8);
                 
                 //Add embedded remote config version to force load from embedded config after app update
                 sb.AppendLine($"{VERSION_PREFIX}{EmbedVersion}");
@@ -226,6 +226,8 @@ namespace Amanotes.Core
                 
                 string filePath = GDKFileUtils.GetPath(fileName);
                 GDKFileUtils.Save(filePath, sb.ToString());
+                GDKPool.Return(sb);
+                
                 Log($"[RemoteConfig] Saved remote config to {filePath}");
                 Profiler.EndSample();
                 NextState();

package/Runtime/AmaGDK.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.68";
+        public const string VERSION = "0.2.70";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
@@ -100,15 +100,12 @@ namespace Amanotes.Core
             Profiler.BeginSample("AmaGDK.InitModules()");
             {
                 User.InitModule();
+                Consent.InitModule();
                 Analytics.InitModule();
                 Ads.InitModule();
                 IAP.InitModule();
                 RemoteConfig.InitModule();
-
-                if (Config.enableAudioModule)
-                {
-                    Audio.InitModule();
-                }
+                if (Config.enableAudioModule) Audio.InitModule();
             }
             Profiler.EndSample();
         }
@@ -128,8 +125,6 @@ namespace Amanotes.Core
 
         IEnumerator InitAdapters(StringBuilder sb)
         {
-            float TIMEOUT = 1;
-            
             // sort on priority
             List<Adapter2> listAdapters = Adapter2.adapterMap
                 .Values.ToList();
@@ -137,21 +132,32 @@ namespace Amanotes.Core
             
             foreach (Adapter2 adapter in listAdapters)
             {
-                // Log($"Initiating {adapter.adapterId} --> initOrder: {adapter.initOrder} | {adapter.status}");
-                float startTime = Time.realtimeSinceStartup;
-                Profiler.BeginSample($"AmaGDK.adapter.InitSDK-{adapter.adapterId}");
+                if (!adapter.enabled)
                 {
-                    adapter.InitSDK();
+                    Log($"Adapter <{adapter.adapterId} is disabled!");
+                    continue;
                 }
-                Profiler.EndSample();
-                
-                yield return GDKUtils.Timeout(TIMEOUT,() => adapter.status != Status.Initialize);
                 
-                if (adapter.status == Status.Initialize)
+                // Log($"Initiating {adapter.adapterId} --> initOrder: {adapter.initOrder} | {adapter.status}");
+                var startTime = Time.realtimeSinceStartup;
+                Profiler.BeginSample($"AmaGDK.adapter.InitSDK-{adapter.adapterId}");
+                adapter.InitSDK();
+                Profiler.EndSample();
+
+                if (adapter.status != Status.Ready)
                 {
-                    LogWarning($"{adapter.adapterId} init time out: {TIMEOUT}");
+                    var beginTime = Time.realtimeSinceStartup;
+                    yield return GDKUtils.Timeout(adapter.Timeout,() => adapter.status != Status.Initialize);
+                    var endTime = Time.realtimeSinceStartup; 
+                        
+                    if (adapter.status == Status.Initialize)
+                    {
+                        LogWarning($"{adapter.adapterId} init time out: {adapter.Timeout:#0.00}");
+                    } else
+                    {
+                        Log($"{adapter.adapterId} init took: {(endTime-beginTime):#0.00} s");
+                    }
                 }
-
                 dispatcher.Dispatch(Event.ADAPTER_READY, adapter.adapterId);
                 sb.AppendLine($"[{(adapter.IsReady ? " OK " : "FAIL")}] {adapter.adapterId} (~ {Time.realtimeSinceStartup - startTime:#0.00}s)");
                 
@@ -170,7 +176,7 @@ namespace Amanotes.Core
             }
             
             var startTime = Time.realtimeSinceStartup;
-            var sb = new StringBuilder();
+            var sb = GDKPool.GetStringBuilder();
 
             InitModules();
             
@@ -205,6 +211,7 @@ namespace Amanotes.Core
             
             sb.Append($"\nMapping UserId: {User.UserId}\n");
             Debug.Log($"AmaGDK v{VERSION} | {READY} in {initDuration:#0.00}s\n\n{sb}");
+            GDKPool.Return(sb);
         }
 
         private void ConfigGeoLocation()
@@ -346,7 +353,9 @@ namespace Amanotes.Core
             public const string FIREBASE_REMOTE_CONFIG = "FirebaseRemoteConfig";
             public const string APPSFLYER = "AppsFlyer";
             public const string IRONSOURCE = "IronSource";
+            public const string MAX = "Max";
             public const string REVENUECAT = "RevenueCat";
+            public const string SQLITE_ANALYTICS = "SqliteAnalytics";
         }
     }
     

package/Runtime/AnalyticQualityAsset.cs

@@ -1,3 +1,4 @@
+using Amanotes.Core.Internal;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -82,14 +83,15 @@ namespace Amanotes.Core
 
         internal void ValidateParams(string eventName, Dictionary<string, object> eventParams)
         {
-            StringBuilder logBuilder = new StringBuilder();
+            var logBuilder = GDKPool.GetStringBuilder();
+            
             logBuilder.AppendLine($"Analytics quality violation found for event <{eventName}>");
-            bool isValid = true;
-            HashSet<string> checkedParameters = new HashSet<string>();
+            var isValid = true;
+            HashSet<string> checkedParameters = GDKPool.GetHashSet();
 
             foreach (var kvp in DicParam)
             {
-                if (!eventParams.ContainsKey(kvp.Key))
+                if (!eventParams.TryGetValue(kvp.Key, out object paramValue))
                 {
                     if (!kvp.Value.isOptional)
                     {
@@ -99,8 +101,6 @@ namespace Amanotes.Core
                     continue;
                 }
 
-                object paramValue = eventParams[kvp.Key];
-
                 if (!ValidateParamType(paramValue, kvp.Value.type))
                 {
                     isValid = false;
@@ -117,8 +117,11 @@ namespace Amanotes.Core
                 isValid = false;
                 logBuilder.AppendLine($"[+] {parameter.Key}");
             }
-
+            
             if (!isValid) LogWarningOnce(logBuilder.ToString());
+            
+            GDKPool.Return(logBuilder);
+            GDKPool.Return(checkedParameters);
         }
 
         private bool ValidateParamType(object paramValue, ParamType paramType)
@@ -179,7 +182,7 @@ namespace Amanotes.Core
         [ContextMenu("Validate Unique EventNames")]
         private void ValidateUniqueEventNames()
         {
-            HashSet<string> eventNames = new HashSet<string>();
+            HashSet<string> eventNames = GDKPool.GetHashSet();
             
             lstEvent = lstEvent.OrderBy(evt => evt.eventName).ToList();
             
@@ -189,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 = new HashSet<string>();
+                HashSet<string> paramNames = GDKPool.GetHashSet();
                 
                 eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
                 
@@ -199,7 +202,11 @@ namespace Amanotes.Core
 
                     if (!paramNames.Add(param.paramName)) Debug.LogWarning($"Duplicate parameter name found in event {eventQuality.eventName}: {param.paramName}. Parameter names must be unique within an event.");
                 }
+                
+                GDKPool.Return(paramNames);
             }
+            
+            GDKPool.Return(eventNames);
             EditorUtility.SetDirty(this);
         }
 #endif