com.amanotes.gdk 0.2.85 → 0.2.87

package/Runtime/AmaGDK.Analytics.cs

@@ -3,6 +3,7 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Text;
 using Amanotes.Core.Internal;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.Profiling;
 using static Amanotes.Core.AmaGDK.Analytics;
@@ -90,7 +91,7 @@ namespace Amanotes.Core
                         return !allowAdapterIds.Contains(adapterId);
                     }
 
-                    Debug.LogWarning("[AmaGDK] Should never be here: overrideConfig == true but no id in listAdapterIds!");
+                    LogWarning("[AmaGDK] Should never be here: overrideConfig == true but no id in listAdapterIds!");
                     return false;
                 }
 
@@ -106,8 +107,14 @@ namespace Amanotes.Core
 
             public static IEventParamsBuilder LogEvent(string eventName)
             {
+                if (listAdapters.Count == 0)
+                {
+                    InitModule();
+                }
+                
                 var result = PrepareEvent(eventName);
                 eventQueue.Enqueue(result);
+                Log($"Queued Event <{result.eventName}>");
                 return result;
             }
 
@@ -364,6 +371,7 @@ namespace Amanotes.Core
                 {
                     sessionStat = new SessionStat();
                 }
+                
                 listAdapters.Clear();
                 listAdapters.AddRange(Adapter2.GetAllAdapter<AnalyticsAdapter>());
             }
@@ -448,35 +456,53 @@ namespace Amanotes.Core
                 string eventNameToSend = GetEventNameToSend(eventParams.eventName, countInSession, totalCount);
                 AnalyticsConfig config = Config.analytics;
                 if (config.normalizeEventName) NormalizeEventName(ref eventNameToSend);
-
-                if (config.showAnalyticsLog)
-                {
-                    ForceLog($"[Analytics] Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventParams.parameters, true)}");
-                }
-                
 	            config.quality.CheckEventQuality(eventParams.eventName, eventParams.parameters);
 	            
-                var inUseAdapterIDs = config.enableEventStat ? new List<string>(listAdapters.Count) : null;
+                List<string> inUseAdapterIDs = config.enableEventStat ? new List<string>(listAdapters.Count) : null;
+                bool effective = ProcessAdapters(eventParams, eventNameToSend, inUseAdapterIDs);
+                HandleEventResult(effective, config, eventNameToSend, countInSession, totalCount, eventParams, inUseAdapterIDs);
+            }
+
+            private static bool ProcessAdapters(EventParams eventParams, string eventNameToSend, List<string> inUseAdapterIDs)
+            {
+                var effective = false;
                 foreach (AnalyticsAdapter m in listAdapters)
                 {
-                    if (eventParams.overrideConfig)
-                    {
-                        // IMPORTANT NOTE:
-                        //
-                        // Once set overrideConfig, we should skip the adapter config completely!!!
-                        //
-                        if (eventParams.IsAdapterForbidden(m.adapterId)) continue;
-                    }
-                    else // Do not remove else
-                    {
-                        if (m.IsForbidden(eventParams.eventName)) continue;
-                    }
+                    if (ShouldSkipAdapter(eventParams, m)) continue;
+                    
+                    effective = true;
                     m.LogEvent(eventNameToSend, eventParams.parameters);
                     inUseAdapterIDs?.Add(m.adapterId);
                 }
-                
-	            GDKUtils.SafeInvoke(OnEventSent, eventNameToSend, eventParams.parameters);
-	            sessionStat?.OnEventSent(eventNameToSend, eventParams.parameters, inUseAdapterIDs);
+                return effective;
+            }
+
+            private static bool ShouldSkipAdapter(EventParams eventParams, AnalyticsAdapter adapter)
+            {
+                // IMPORTANT NOTE:
+                //
+                // Once set overrideConfig, we should skip the adapter config completely!!!
+                //
+                return eventParams.overrideConfig 
+                    ? eventParams.IsAdapterForbidden(adapter.adapterId)
+                    : adapter.IsForbidden(eventParams.eventName);
+            }
+
+            private static void HandleEventResult(bool effective, AnalyticsConfig config, string eventNameToSend, int countInSession, int totalCount, EventParams eventParams, List<string> inUseAdapterIDs)
+            {
+                if (effective)
+                {
+                    if (config.showAnalyticsLog)
+                    {
+                        ForceLog($"[Analytics] Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventParams.parameters, true)}");
+                    }
+                    GDKUtils.SafeInvoke(OnEventSent, eventNameToSend, eventParams.parameters);
+                    sessionStat?.OnEventSent(eventNameToSend, eventParams.parameters, inUseAdapterIDs);
+                }
+                else
+                {
+                    LogError($"Event <{eventParams}> has been skipped (no matching Adapter)\n{JsonUtility.ToJson(eventParams)}");
+                }
             }
 			
             internal static void LogEventImmediately(EventParams eventParams)
@@ -551,63 +577,89 @@ namespace Amanotes.Core
                     var hasChanged = false;
                     var trimKey = key.Trim();
                     
-                    foreach (var c in trimKey)
-                    {
-                        var isLetter = IsAlphabet(c);
-                        var isNumber = char.IsDigit(c);
-
-                        if (c == '_' || isLetter || isNumber)
-                        {
-                            tempKey.Append(c);
-                            continue;
-                        }
-                        
-                        hasChanged = true;
-                        if (c == ' ' || c == '-')
-                        {
-                            tempKey.Append('_');
-                        }
-                    }
-
-                    if (hasChanged && willLog)
-                    {
-                        tempLog.Append(" - Name may only contain alphanumeric characters and underscores");
-                    }
+                    hasChanged = ProcessCharacters(trimKey, tempKey, tempLog, willLog, hasChanged);
+                    hasChanged = EnsureValidStart(tempKey, tempLog, willLog, hasChanged, key);
+                    hasChanged = HandleReservedPrefixes(tempKey, tempLog, willLog, hasChanged, key);
+                    hasChanged = ValidateLength(trimKey, tempKey, tempLog, willLog, hasChanged, key);
                     
-                    if (tempKey.Length > 0 && !IsAlphabet(tempKey[0]))
-                    {
-                        hasChanged = true;
-                        tempKey.Insert(0, 'E');
-                        if (willLog) tempLog.Append($" - Name must start with a letter: <{key}>");
-                    }
+                    ApplyChanges(dryRun, warningLog, tempLog, hasChanged, ref key, tempKey);
                     
-                    foreach (var prefix in reservedPrefixes)
-                    {
-                        if (tempKey.Length < prefix.Key.Length || !StringStartsWith(tempKey, prefix.Key)) continue;
-                        hasChanged = true;
-                        tempKey.Remove(0, prefix.Key.Length);
-                        tempKey.Insert(0, prefix.Value);
-                        if (willLog) tempLog.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
-                    }
+                    GDKPool.Return(tempLog);
+                    GDKPool.Return(tempKey);
+                }
+                Profiler.EndSample();
+            }
 
-                    if (trimKey.Length > 40)
+            private static bool ProcessCharacters(string trimKey, StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged)
+            {
+                foreach (var c in trimKey)
+                {
+                    var isLetter = IsAlphabet(c);
+                    var isNumber = char.IsDigit(c);
+
+                    if (c == '_' || isLetter || isNumber)
                     {
-                        hasChanged = true;
-                        if (willLog) tempLog.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
-                        tempKey.Length = 40;
+                        tempKey.Append(c);
+                        continue;
                     }
                     
-                    if (dryRun)
+                    hasChanged = true;
+                    if (c == ' ' || c == '-')
                     {
-                        warningLog.Append(tempLog);
-                    } else {
-                        if (hasChanged) key = tempKey.ToString();
+                        tempKey.Append('_');
                     }
-                    
-                    GDKPool.Return(tempLog);
-                    GDKPool.Return(tempKey);
                 }
-                Profiler.EndSample();
+
+                if (hasChanged && willLog)
+                {
+                    tempLog.Append(" - Name may only contain alphanumeric characters and underscores");
+                }
+                return hasChanged;
+            }
+
+            private static bool EnsureValidStart(StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged, string key)
+            {
+                if (tempKey.Length > 0 && !IsAlphabet(tempKey[0]))
+                {
+                    hasChanged = true;
+                    tempKey.Insert(0, 'E');
+                    if (willLog) tempLog.Append($" - Name must start with a letter: <{key}>");
+                }
+                return hasChanged;
+            }
+
+            private static bool HandleReservedPrefixes(StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged, string key)
+            {
+                foreach (var prefix in reservedPrefixes)
+                {
+                    if (tempKey.Length < prefix.Key.Length || !StringStartsWith(tempKey, prefix.Key)) continue;
+                    hasChanged = true;
+                    tempKey.Remove(0, prefix.Key.Length);
+                    tempKey.Insert(0, prefix.Value);
+                    if (willLog) tempLog.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
+                }
+                return hasChanged;
+            }
+
+            private static bool ValidateLength(string trimKey, StringBuilder tempKey, StringBuilder tempLog, bool willLog, bool hasChanged, string key)
+            {
+                if (trimKey.Length > 40)
+                {
+                    hasChanged = true;
+                    if (willLog) tempLog.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
+                    tempKey.Length = 40;
+                }
+                return hasChanged;
+            }
+
+            private static void ApplyChanges(bool dryRun, StringBuilder warningLog, StringBuilder tempLog, bool hasChanged, ref string key, StringBuilder tempKey)
+            {
+                if (dryRun)
+                {
+                    warningLog.Append(tempLog);
+                } else {
+                    if (hasChanged) key = tempKey.ToString();
+                }
             }
             
             private static bool StringStartsWith(StringBuilder stringBuilder, string prefix)
@@ -777,7 +829,7 @@ namespace Amanotes.Core
                 {
                     if (cachedEventDetails.ContainsKey(ed.eventName))
                     {
-                        Debug.LogWarning($"EventName <{ed.eventName}> existed!");
+                        LogWarning($"EventName <{ed.eventName}> existed!");
                         return false;
                     }
                     
@@ -1039,18 +1091,28 @@ namespace Amanotes.Core
                 LogWarning("OnlyTo() can only be set once!");
                 return ap;
             }
-
-            eventData.overrideConfig = true;
-            eventData.allowAdapterIds ??= GDKPool.GetHashSet();
             
+            var h = GDKPool.GetHashSet();
             foreach (string mId in analyticIds)
             {
-                if (!listAdapters.Exists(a => a.adapterId == mId))
+                if (listAdapters.Count > 0 && !listAdapters.Exists(a => a.adapterId == mId))
                 {
-                    LogError($"Cannot send event <{eventData.eventName}> to <{mId}>. Analytics adapter for <{mId}> is not available.");
+                    LogError($"Cannot send event <{eventData.eventName}> to <{mId}>. Analytics adapter for <{mId}> is not available.\n" +
+                        $"listAdapters ({listAdapters.Count}): [{string.Join(",", listAdapters.Select(item=>item.adapterId).ToArray())}]");
                     continue;
                 }
-                eventData.allowAdapterIds.Add(mId);
+                h.Add(mId);
+            }
+
+            eventData.overrideConfig = true;
+            if (h.Count > 0)
+            {
+                eventData.allowAdapterIds ??= h;    
+            }
+            else
+            {
+                // No valid adapters found, create empty set to ensure event is skipped
+                eventData.allowAdapterIds ??= GDKPool.GetHashSet();
             }
             
             return ap;

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -259,43 +259,9 @@ namespace Amanotes.Core
                 try
                 {
                     DictConfig.Clear();
-                    using (StreamReader sr = new StreamReader(GDKFileUtils.GetPath(fileName)))
-                    {
-                        //Check new app update
-                        string firstLine = sr.ReadLine();
-                        if (firstLine == null)
-                        {
-                            NextState(false);
-                            return;
-                        }
-                        if (ShouldClearCache(firstLine))
-                        {
-                            GDKFileUtils.Delete(fileName);
-                            string oldVersion = firstLine.StartsWith(VERSION_PREFIX) ? firstLine : "<none>";
-                            Log($"[RemoteConfig] Cached remote config cleared due to embed version changed:\n{oldVersion} -> {EmbedVersion}");
-                            NextState(false);
-                            return;
-                        }
-                        
-                        //Read key-value
-                        string line;
-                        int lineNo = 1;
-                        while ((line = sr.ReadLine()) != null)
-                        {
-                            lineNo++;
-                            var idx = line.IndexOf('\t');
-                            if (idx == -1)
-                            {
-                                LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineNo} of cache. Content:\n<{line}>");
-                                continue;
-                            }
-                            string key = line.Substring(0, idx);
-                            string value = line.Substring(idx + 1);
-                            DictConfig.Add(key, Decode(value));
-                        }
-                    }
-                    Source = RemoteConfigSource.LocalCache;
-                    Log("[RemoteConfig] Load from cache");
+                    bool success = ReadCacheFile();
+                    Profiler.EndSample();
+                    NextState(success);
                 }
                 catch (Exception ex)
                 {
@@ -303,11 +269,55 @@ namespace Amanotes.Core
                     _cacheExisted = false;
                     Profiler.EndSample();
                     NextState(false);
-                    return;
                 }
+            }
 
-                Profiler.EndSample();
-                NextState(true);
+            static bool ReadCacheFile()
+            {
+                using (StreamReader sr = new StreamReader(GDKFileUtils.GetPath(fileName)))
+                {
+                    string firstLine = sr.ReadLine();
+                    if (firstLine == null) return false;
+                    
+                    if (!ValidateCacheVersion(firstLine)) return false;
+                    
+                    ReadConfigKeyValues(sr);
+                }
+                
+                Source = RemoteConfigSource.LocalCache;
+                Log("[RemoteConfig] Load from cache");
+                return true;
+            }
+
+            static bool ValidateCacheVersion(string firstLine)
+            {
+                if (ShouldClearCache(firstLine))
+                {
+                    GDKFileUtils.Delete(fileName);
+                    string oldVersion = firstLine.StartsWith(VERSION_PREFIX) ? firstLine : "<none>";
+                    Log($"[RemoteConfig] Cached remote config cleared due to embed version changed:\n{oldVersion} -> {EmbedVersion}");
+                    return false;
+                }
+                return true;
+            }
+
+            static void ReadConfigKeyValues(StreamReader sr)
+            {
+                string line;
+                int lineNo = 1;
+                while ((line = sr.ReadLine()) != null)
+                {
+                    lineNo++;
+                    var idx = line.IndexOf('\t');
+                    if (idx == -1)
+                    {
+                        LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineNo} of cache. Content:\n<{line}>");
+                        continue;
+                    }
+                    string key = line.Substring(0, idx);
+                    string value = line.Substring(idx + 1);
+                    DictConfig.Add(key, Decode(value));
+                }
             }
 
             static void LoadEmbedConfig()

package/Runtime/AmaGDK.Singleton.cs

@@ -12,6 +12,8 @@ namespace Amanotes.Core
         
         private void Awake()
         {
+            Log("Awake()");
+            
             if (_instance != null)
             {
                 LogWarning(MULTIPLE_INSTANCE);

package/Runtime/AmaGDK.cs

@@ -27,7 +27,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.85";
+        public const string VERSION = "0.2.87";
         
         internal static Status _status = Status.None;
         internal static ConfigAsset _config = null;
@@ -200,6 +200,8 @@ namespace Amanotes.Core
         
         IEnumerator InitRoutine()
         {
+            Log("InitRoutine!");
+            
             _allowInit = _allowInit || autoInit;
             
             if (Config == null)

package/Runtime/AnalyticQualityAsset.cs

@@ -54,31 +54,27 @@ namespace Amanotes.Core
             }
         }
 
+        private static readonly HashSet<Type> NumericTypes = new HashSet<Type>
+        {
+            typeof(int), typeof(long), typeof(short), typeof(byte),
+            typeof(double), typeof(float), typeof(decimal),
+            typeof(uint), typeof(ulong), typeof(ushort), typeof(sbyte)
+        };
+
         private bool IsNumericType(Type type)
         {
-            return type == typeof(int) ||
-                   type == typeof(long) ||
-                   type == typeof(short) ||
-                   type == typeof(byte) ||
-                   type == typeof(double) ||
-                   type == typeof(float) ||
-                   type == typeof(decimal) ||
-                   type == typeof(uint) ||
-                   type == typeof(ulong) ||
-                   type == typeof(ushort) ||
-                   type == typeof(sbyte);
+            return NumericTypes.Contains(type);
         }
 
+        private static readonly HashSet<Type> IntegerTypes = new HashSet<Type>
+        {
+            typeof(sbyte), typeof(byte), typeof(short), typeof(ushort),
+            typeof(int), typeof(uint), typeof(long), typeof(ulong)
+        };
+
         private bool IsIntegerType(Type type)
         {
-            return type == typeof(sbyte) ||
-                   type == typeof(byte) ||
-                   type == typeof(short) ||
-                   type == typeof(ushort) ||
-                   type == typeof(int) ||
-                   type == typeof(uint) ||
-                   type == typeof(long) ||
-                   type == typeof(ulong);
+            return IntegerTypes.Contains(type);
         }
 
         internal void ValidateParams(string eventName, Dictionary<string, object> eventParams)
@@ -89,6 +85,19 @@ namespace Amanotes.Core
             var isValid = true;
             HashSet<string> checkedParameters = GDKPool.GetHashSet();
 
+            isValid &= ValidateRequiredParams(eventParams, logBuilder, checkedParameters);
+            isValid &= ValidateExtraParams(eventParams, logBuilder, checkedParameters);
+            
+            if (!isValid) LogWarningOnce(logBuilder.ToString());
+            
+            GDKPool.Return(logBuilder);
+            GDKPool.Return(checkedParameters);
+        }
+
+        private bool ValidateRequiredParams(Dictionary<string, object> eventParams, StringBuilder logBuilder, HashSet<string> checkedParameters)
+        {
+            bool isValid = true;
+            
             foreach (var kvp in DicParam)
             {
                 if (!eventParams.TryGetValue(kvp.Key, out object paramValue))
@@ -109,7 +118,14 @@ namespace Amanotes.Core
 
                 checkedParameters.Add(kvp.Key);
             }
+            
+            return isValid;
+        }
 
+        private bool ValidateExtraParams(Dictionary<string, object> eventParams, StringBuilder logBuilder, HashSet<string> checkedParameters)
+        {
+            bool isValid = true;
+            
             foreach (var parameter in eventParams)
             {
                 if (checkedParameters.Contains(parameter.Key)) continue;
@@ -118,10 +134,7 @@ namespace Amanotes.Core
                 logBuilder.AppendLine($"[+] {parameter.Key}");
             }
             
-            if (!isValid) LogWarningOnce(logBuilder.ToString());
-            
-            GDKPool.Return(logBuilder);
-            GDKPool.Return(checkedParameters);
+            return isValid;
         }
 
         private bool ValidateParamType(object paramValue, ParamType paramType)
@@ -188,26 +201,44 @@ namespace Amanotes.Core
             
             foreach (EventQuality eventQuality in lstEvent)
             {
-                if (string.IsNullOrWhiteSpace(eventQuality.eventName)) Debug.LogWarning("Event name cannot be empty or whitespace.");
+                ValidateEventName(eventQuality.eventName, eventNames);
+                ValidateEventParameters(eventQuality);
+            }
+            
+            GDKPool.Return(eventNames);
+            EditorUtility.SetDirty(this);
+        }
 
-                if (!eventNames.Add(eventQuality.eventName)) Debug.LogWarning($"Duplicate event name found: {eventQuality.eventName}. Event names must be unique.");
+        private void ValidateEventName(string eventName, HashSet<string> eventNames)
+        {
+            if (string.IsNullOrWhiteSpace(eventName)) 
+                Debug.LogWarning("Event name cannot be empty or whitespace.");
 
-                HashSet<string> paramNames = GDKPool.GetHashSet();
-                
-                eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
-                
-                foreach (var param in eventQuality.lstParam)
-                {
-                    if (string.IsNullOrWhiteSpace(param.paramName)) Debug.LogWarning("Event parameter name cannot be empty or whitespace.");
+            if (!eventNames.Add(eventName)) 
+                Debug.LogWarning($"Duplicate event name found: {eventName}. Event names must be unique.");
+        }
 
-                    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);
+        private void ValidateEventParameters(EventQuality eventQuality)
+        {
+            HashSet<string> paramNames = GDKPool.GetHashSet();
+            
+            eventQuality.lstParam = eventQuality.lstParam.OrderBy(param => param.paramName).ToList();
+            
+            foreach (var param in eventQuality.lstParam)
+            {
+                ValidateParameterName(param.paramName, eventQuality.eventName, paramNames);
             }
             
-            GDKPool.Return(eventNames);
-            EditorUtility.SetDirty(this);
+            GDKPool.Return(paramNames);
+        }
+
+        private void ValidateParameterName(string paramName, string eventName, HashSet<string> paramNames)
+        {
+            if (string.IsNullOrWhiteSpace(paramName)) 
+                Debug.LogWarning("Event parameter name cannot be empty or whitespace.");
+
+            if (!paramNames.Add(paramName)) 
+                Debug.LogWarning($"Duplicate parameter name found in event {eventName}: {paramName}. Parameter names must be unique within an event.");
         }
 #endif
 

package/Runtime/AudioToolkit/Plugins/AudioDeviceDetector.cs

@@ -162,10 +162,7 @@ namespace Amanotes.Core
 
         private static string RemoveSurrogatePairs(string str, string replacementCharacter = "?")
         {
-            if (str == null)
-            {
-                return null;
-            }
+            if (str == null) return null;
 
             StringBuilder sb = null;
             for (var i = 0; i < str.Length; i++)
@@ -174,19 +171,8 @@ namespace Amanotes.Core
 
                 if (char.IsSurrogate(ch))
                 {
-                    if (sb == null)
-                    {
-                        sb = GDKPool.GetStringBuilder();
-                        sb.Append(str, 0, i);
-                    }
-                    
-                    sb.Append(replacementCharacter);
-
-                    // If there is a high+low surrogate, skip the low surrogate
-                    if (i + 1 < str.Length && char.IsHighSurrogate(ch) && char.IsLowSurrogate(str[i + 1]))
-                    {
-                        i++;
-                    }
+                    sb = HandleSurrogateCharacter(str, i, sb, replacementCharacter, out int skipCount);
+                    i += skipCount;
                 }
                 else
                 {
@@ -196,6 +182,34 @@ namespace Amanotes.Core
             
             return sb == null ? str : GDKPool.ReturnString(sb);
         }
+
+        private static StringBuilder HandleSurrogateCharacter(string str, int index, StringBuilder sb, string replacementCharacter, out int skipCount)
+        {
+            skipCount = 0;
+            
+            if (sb == null)
+            {
+                sb = GDKPool.GetStringBuilder();
+                sb.Append(str, 0, index);
+            }
+            
+            sb.Append(replacementCharacter);
+
+            // If there is a high+low surrogate, skip the low surrogate
+            if (ShouldSkipLowSurrogate(str, index))
+            {
+                skipCount = 1;
+            }
+            
+            return sb;
+        }
+
+        private static bool ShouldSkipLowSurrogate(string str, int index)
+        {
+            return index + 1 < str.Length && 
+                   char.IsHighSurrogate(str[index]) && 
+                   char.IsLowSurrogate(str[index + 1]);
+        }
     }
 
     internal enum AudioDeviceType

package/Runtime/Core/GDKDispatcher.cs

@@ -44,9 +44,11 @@ namespace Amanotes.Core.Internal
                     return false;
                 }
 
-                if (args.Length != nParams)
+                // Fix: https://amanotes.sentry.io/issues/6366288384/events/d45dd8fb736f43d0a8e2aec0df0f173d/
+                int argsLength = args != null ? args.Length : 0;
+                if (argsLength != nParams)
                 {
-                    GDKUtils.ThrowExceptionInEditor($"Dispatch <{eventName}> with incorrect number of params, expecting {nParams}, got {args.Length}!",
+                    GDKUtils.ThrowExceptionInEditor($"Dispatch <{eventName}> with incorrect number of params, expecting {nParams}, got {argsLength}!",
                         (m) => new TargetParameterCountException(m));
                     return false;
                 }