com.amanotes.gdk 0.2.65-4 → 0.2.65-5

package/CHANGELOG.md

@@ -1,7 +1,16 @@
 # Changelog
 
-## [0.2.66 - 2024-06-13]
-- [Fix] Missing Google CMP in package release
+## [0.2.65-5 - 2024-06-17]
+- [Dev] Update for GDKTest Unity 2022.3 project
+- [Dev] Update for GDKTest Unity 2021.3 project
+- [Dev] Enable pipeline for unity 2020
+- [Dev] Refactor GDKSemVer
+- [Dev] Various minor fixes for class scope & syntax
+- [Dev] Clean up GDKDispatcher
+- [Fix] Temp patch to fix RevenueCat crash
+- [Fix] RevenueCat adapter ready early
+- [Dev] Degrade GDKDev project to Unity 2020
+- [Dev] Audio module supports Unity 2020
 
 ## [0.2.65 - 2024-06-13]
 - [Dev] Add GDKRoutine

package/Editor/Extra/SDKVersionTracking.AirTable.cs

@@ -38,7 +38,7 @@ namespace Amanotes.Editor
                 {"RawData", rawData }
             };
             string json = JsonUtils.DictionaryToJson(buildInfo, false, false);
-            SendDataToAirTable(json);
+            Task.Run(()=>SendDataToAirTable(json));
         }
         
         private static async Task SendDataToAirTable(string payload)

package/Editor/MatchSDKVersion.cs

@@ -48,10 +48,10 @@ namespace Amanotes.Core
             File.WriteAllLines(filePath, lines);
         }
 
-        private static KeyValuePair<int, SemVer> FindNearestLowerVersion(SemVer inputVersion, Dictionary<int, SemVer> defineLines)
+        private static KeyValuePair<int, GDKSemVer> FindNearestLowerVersion(GDKSemVer inputVersion, Dictionary<int, GDKSemVer> defineLines)
         {
-            KeyValuePair<int, SemVer> versionLessAndNearest = default;
-            SemVer bestMatch = SemVer.ZERO;
+            KeyValuePair<int, GDKSemVer> versionLessAndNearest = default;
+            GDKSemVer bestMatch = GDKSemVer.ZERO;
             
             foreach (var kvp in defineLines)
             {
@@ -67,9 +67,9 @@ namespace Amanotes.Core
             return versionLessAndNearest;
         }
         
-        private static Dictionary<int, SemVer> GetSemVersDefine(string code)
+        private static Dictionary<int, GDKSemVer> GetSemVersDefine(string code)
         {
-            Dictionary<int, SemVer> defineLines = new Dictionary<int, SemVer>();
+            Dictionary<int, GDKSemVer> defineLines = new Dictionary<int, GDKSemVer>();
 
             string[] lines = code.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
             for (int i = 0; i < lines.Length; i++)
@@ -78,7 +78,7 @@ namespace Amanotes.Core
 
                 if (Regex.IsMatch(line, @"^(\/\/\s*)?#define\s+"))
                 {
-                    defineLines.Add(i, new SemVer(GetVersionNumber(line)));
+                    defineLines.Add(i, new GDKSemVer(GetVersionNumber(line)));
                 }
             }
 
@@ -122,9 +122,9 @@ namespace Amanotes.Core
 
                 if (file != null)
                 {
-                    Dictionary<int, SemVer> defineLines = GetSemVersDefine(File.ReadAllText(file.FullName));
+                    Dictionary<int, GDKSemVer> defineLines = GetSemVersDefine(File.ReadAllText(file.FullName));
 
-                    KeyValuePair<int, SemVer> r = FindNearestLowerVersion(version, defineLines);
+                    KeyValuePair<int, GDKSemVer> r = FindNearestLowerVersion(version, defineLines);
                     
                     if (r.Value.isValid)
                     {

package/Editor/Utils/AmaGDKEditor.ExtractVersion.cs

@@ -18,14 +18,14 @@ namespace Amanotes.Editor
     internal class IronSourceSDKAdapter
     {
         public string name;
-        public SemVer semVer;
+        public GDKSemVer semVer;
         public string version;
 
         public IronSourceSDKAdapter(string name, string version)
         {
             this.name = name;
             this.version = version;
-            semVer = new SemVer(version);
+            semVer = new GDKSemVer(version);
         }
     }
 
@@ -36,11 +36,11 @@ namespace Amanotes.Editor
         internal static void ClearCache(){ _cache.Clear(); }
         
         public string sdkId;
-        public SemVer adapterVersion;
-        public SemVer sdkVersion;
+        public GDKSemVer adapterVersion;
+        public GDKSemVer sdkVersion;
 
-        public bool sdkInstalled => sdkVersion > SemVer.ZERO;
-        public bool adapterInstalled => adapterVersion > SemVer.ZERO;
+        public bool sdkInstalled => sdkVersion > GDKSemVer.ZERO;
+        public bool adapterInstalled => adapterVersion > GDKSemVer.ZERO;
 
         public string ToTSVString()
         {
@@ -53,8 +53,8 @@ namespace Amanotes.Editor
             result = new SDKStatus
             {
                 sdkId = sdkId,
-                adapterVersion = new SemVer(ExtractVersion.GDKAdapter(sdkId)),
-                sdkVersion = new SemVer(ExtractVersion.ThirdParty(sdkId))
+                adapterVersion = new GDKSemVer(ExtractVersion.GDKAdapter(sdkId)),
+                sdkVersion = new GDKSemVer(ExtractVersion.ThirdParty(sdkId))
             };
 
             // Debug.LogWarning($"Get <{sdkId} --> " + result.adapterVersion + " | " + result.sdkVersion);

package/Runtime/AmaGDK.Ads.cs

@@ -227,37 +227,37 @@ namespace Amanotes.Core
 
             public static void OnInter_Request(Action callback)
             {
-                dispatcher.AddListener(Event.INTER_REQUEST, callback, false);
+                dispatcher.AddListener(Event.INTER_REQUEST, callback);
             }
 
             public static void OnInter_ShowCalled(Action callback)
             {
-                dispatcher.AddListener(Event.INTER_SHOW_CALLED, callback, false);
+                dispatcher.AddListener(Event.INTER_SHOW_CALLED, callback);
             }
         
             public static void OnReward_ShowCalled(Action callback)
             {
-                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_CALLED, callback, false);
+                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_CALLED, callback);
             }
             
             public static void OnInter_ShowReady(Action callback)
             {
-                dispatcher.AddListener(Event.INTER_SHOW_READY, callback, false);
+                dispatcher.AddListener(Event.INTER_SHOW_READY, callback);
             }
         
             public static void OnReward_ShowReady(Action callback)
             {
-                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_READY, callback, false);
+                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_READY, callback);
             }
         
             public static void OnInter_ShowNotReady(Action<AdShowReadyStatus> callback)
             {
-                dispatcher.AddListener(Event.INTER_SHOW_NOT_READY, callback, false);
+                dispatcher.AddListener(Event.INTER_SHOW_NOT_READY, callback);
             }
         
             public static void OnReward_ShowNotReady(Action<AdShowReadyStatus> callback)
             {
-                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_NOT_READY, callback, false);
+                dispatcher.AddListener(Event.REWARD_VIDEO_SHOW_NOT_READY, callback);
             }
         }
 

package/Runtime/AmaGDK.IAP.cs

@@ -204,14 +204,25 @@ namespace Amanotes.Core
 
                 public void Sync()
                 {
-                    activeSubscriptionId = Adapter?.GetActiveSubscriptionId();
-                    subscriptionPeriodType = Adapter?.GetSubscriptionPeriodType();
-                    purchasedProducts = Adapter?.GetPurchasedProducts();
-                    _subscriptionLastPurchaseDate = Adapter?.GetSubscriptionLastPurchaseDate();
+                    GDKUtils.StartCoroutine(SyncRoutine());
+                }
+
+                IEnumerator SyncRoutine()
+                {
+                    if (Adapter == null)
+                    {
+                        LogWarning("[IAP] Adapter is not available");
+                        yield break;
+                    }
+                    yield return new WaitUntil(() => Adapter.IsReady);
+                    activeSubscriptionId = Adapter.GetActiveSubscriptionId();
+                    subscriptionPeriodType = Adapter.GetSubscriptionPeriodType();
+                    purchasedProducts = Adapter.GetPurchasedProducts();
+                    _subscriptionLastPurchaseDate = Adapter.GetSubscriptionLastPurchaseDate();
                     subscriptionLastPurchaseDate = _subscriptionLastPurchaseDate?.ToString(DATE_FORMAT);
-                    _subscriptionExpiredDate = Adapter?.GetSubscriptionExpiredDate();
+                    _subscriptionExpiredDate = Adapter.GetSubscriptionExpiredDate();
                     subscriptionExpiredDate = _subscriptionExpiredDate?.ToString(DATE_FORMAT);
-                    _unsubscribedDate = Adapter?.GetUnsubscribedDate();
+                    _unsubscribedDate = Adapter.GetUnsubscribedDate();
                     unsubscribedDate = _unsubscribedDate?.ToString(DATE_FORMAT);
                     this.SaveJsonToFile();
                 }

package/Runtime/AmaGDK.UserProfile.cs

@@ -22,7 +22,7 @@ namespace Amanotes.Core
         /// <param name="onUserIdChange"></param>
         public static void SetCallback_OnUserIdUpdated(Action<string> onUserIdChange)
         {
-            dispatcher.AddListener(Event.GDK_USER_ID_UPDATED, onUserIdChange, false);
+            dispatcher.AddListener(Event.GDK_USER_ID_UPDATED, onUserIdChange);
         }
         
         [Serializable]

package/Runtime/AmaGDK.cs

@@ -17,10 +17,12 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.65-4";
+        public const string VERSION = "0.2.65-5";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
+        
+        internal static readonly GDKDispatcher dispatcher = new GDKDispatcher();
         internal static readonly GDKGeoLocation GeoLocation = new GDKGeoLocation();
         internal static readonly GDKServerTime ServerTime = new GDKServerTime();
         private static readonly ForceQuitMonitor ForceQuit = new ForceQuitMonitor();
@@ -328,7 +330,7 @@ namespace Amanotes.Core
                 return;
             }
             
-            dispatcher.AddListener(Event.ADAPTER_READY, onAdapterReady, false);
+            dispatcher.AddListener(Event.ADAPTER_READY, onAdapterReady);
         }
     }
 

package/Runtime/AudioToolkit/AmaGDK.Audio.cs

@@ -46,19 +46,19 @@ namespace Amanotes.Core
                     return;
                 }
 
-                dispatcher.AddListener(Event.GDK_AUDIO_INFO_CHANGE, onAudioDeviceChange, false);
+                dispatcher.AddListener(Event.GDK_AUDIO_INFO_CHANGE, onAudioDeviceChange);
             }
 
             public static void SetOnAudioInterruptedCallback(Action beginCallback, Action endCallback)
             {
                 if (beginCallback != null)
                 {
-                    dispatcher.AddListener(Event.GDK_AUDIO_INTERRUPT_BEGIN, beginCallback, false);
+                    dispatcher.AddListener(Event.GDK_AUDIO_INTERRUPT_BEGIN, beginCallback);
                 }
 
                 if (endCallback != null)
                 {
-                    dispatcher.AddListener(Event.GDK_AUDIO_INTERRUPT_END, endCallback, false);
+                    dispatcher.AddListener(Event.GDK_AUDIO_INTERRUPT_END, endCallback);
                 }
             }
         }

package/Runtime/Core/GDKDispatcher.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Amanotes.Core.Internal
+{
+    public class GDKDispatcher
+    {
+        private class EventEntry
+        {
+            public int nParams;
+            private bool _dispatching;
+            private Delegate callbacks;
+            private Delegate callbackOnce;
+
+            public bool hasCallback => callbacks != null || callbackOnce != null;
+
+            internal void Add(Delegate d, bool once)
+            {
+                callbackOnce = Delegate.Remove(callbackOnce, d);
+                callbacks = Delegate.Remove(callbacks, d);
+                if (once)
+                {
+                    callbackOnce = Delegate.Combine(callbackOnce, d);
+                } else
+                {
+                    callbacks = Delegate.Combine(callbacks, d);
+                }
+            }
+
+            internal void Remove(Delegate d)
+            {
+                callbackOnce = Delegate.Remove(callbackOnce, d);
+                callbacks = Delegate.Remove(callbacks, d);
+            }
+
+            internal bool Dispatch(string eventName, object[] args)
+            {
+                if (_dispatching)
+                {
+                    GDKUtils.ThrowExceptionInEditor($"Nested dispatching is not supported, eventName: <{eventName}>",
+                        (m) => new InvalidOperationException(m));
+                    return false;
+                }
+
+                if (args.Length != nParams)
+                {
+                    GDKUtils.ThrowExceptionInEditor($"Dispatch <{eventName}> with incorrect number of params, expecting {nParams}, got {args.Length}!",
+                        (m) => new TargetParameterCountException(m));
+                    return false;
+                }
+
+                _dispatching = true;
+                callbacks?.DynamicInvoke(args);
+                callbackOnce?.DynamicInvoke(args);
+                callbackOnce = null;
+                _dispatching = false;
+
+                return true;
+            }
+        }
+
+        private readonly Dictionary<string, EventEntry> _eventMap = new Dictionary<string, EventEntry>();
+        public void ClearAndReset()
+        {
+            _eventMap.Clear();
+        }
+
+        private EventEntry Get(string eventName)
+        {
+            if (string.IsNullOrEmpty(eventName)) return null;
+            _eventMap.TryGetValue(eventName, out EventEntry entry);
+            return entry;
+        }
+
+        public void AddListener(string eventName, Delegate d, bool once = false)
+        {
+            if (d == null)
+            {
+                Debug.LogWarning("Dispatcher.Add() error: d == null");
+                return;
+            }
+
+            int nParams = d.Method.GetParameters().Length;
+            EventEntry entry = Get(eventName);
+
+            if (entry == null)
+            {
+                entry = new EventEntry { nParams = nParams };
+                _eventMap.Add(eventName, entry);
+            } else if (nParams != entry.nParams)
+            {
+                GDKUtils.ThrowExceptionInEditor(string.Format(Internal.Messsage.DISPATCHER_WRONG_NUMBER_OF_PARAMS, eventName, entry.nParams, nParams),
+                    (m) => new TargetParameterCountException(m));
+                return;
+            }
+
+            // Debug.Log("Add: " + eventName + " --> " + d + " | " + once);
+            entry.Add(d, once);
+        }
+
+        public void RemoveListener(string eventName, Delegate d)
+        {
+            if (d == null)
+            {
+                Debug.LogWarning("Dispatcher.Remove() error: d == null");
+                return;
+            }
+
+            EventEntry entry = Get(eventName);
+            entry?.Remove(d);
+        }
+
+        public void ClearListeners(string eventName)
+        {
+            if (_eventMap.ContainsKey(eventName)) _eventMap.Remove(eventName);
+        }
+        public void Dispatch(string eventName, params object[] data)
+        {
+            if (string.IsNullOrEmpty(eventName))
+            {
+                GDKUtils.ThrowExceptionInEditor(
+                    $"Invalid eventName: <{eventName}> (should not be null or empty)",
+                    (m) => new ArgumentException(m));
+                return;
+            }
+
+            EventEntry entry = Get(eventName);
+            if (entry == null) return;
+
+            if (!entry.hasCallback)
+            {
+                // string[] result = _eventMap
+                //     .Select(kvp => kvp.Key + ":" + kvp.Value + "\n")
+                //     .ToArray();
+                //
+                // Debug.LogWarning("AmaGDK [Event] No listener of type <" + eventName + ">\n\nRegistered events:\n\n" + string.Join("", result));
+                return;
+            }
+
+            GDKUtils.SafeInvoke(() => entry.Dispatch(eventName, data));
+        }
+    }
+}

package/Runtime/Core/GDKDispatcher.cs.meta

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

package/Runtime/Core/GDKRoutine.cs

@@ -1,18 +1,19 @@
 using System;
 using System.Collections;
 using UnityEngine;
+
 namespace Amanotes.Core.Internal
 {
-    [Flags]
-    internal enum RoutineStatus
-    {
-        None,
-        Started = 1,
-        Stopped = 2
-    }
-    
     public class GDKRoutine
     {
+        [Flags]
+        internal enum RoutineStatus
+        {
+            None,
+            Started = 1,
+            Stopped = 2
+        }
+        
         private RoutineStatus status;
         private readonly IEnumerator action;
         private Coroutine routine;
@@ -55,7 +56,7 @@ namespace Amanotes.Core.Internal
 
         public static void StopCoroutine(GDKRoutine gdkRoutine)
         {
-            gdkRoutine.StopRoutine();
+            if (gdkRoutine != null) gdkRoutine.StopRoutine();
         }
     }
 }

package/Runtime/Core/GDKSemVer.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using UnityEngine.Profiling;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core.Internal
+{
+    public readonly struct GDKSemVer : IComparable<GDKSemVer>, IComparer<GDKSemVer>
+    {
+        // Zero version constant
+        public static readonly GDKSemVer ZERO = new GDKSemVer(0, 0, 0);
+
+        // Regex for parsing semantic versioning patterns, compiled for performance
+        private static readonly Regex VERSION_PATTERN = new Regex(@"^(\d+)\.(\d+)(?:\.(\d+))?(?:\.(\d+))?$", RegexOptions.Compiled);
+
+        // Version components
+        public readonly int major;
+        public readonly int minor;
+        public readonly int patch;
+        public readonly int extra;
+
+        // Constructor for direct value initialization
+        public GDKSemVer(int major, int minor, int patch, int extra = -1)
+        {
+            this.major = major;
+            this.minor = minor;
+            this.patch = patch;
+            this.extra = extra;
+        }
+
+        // Constructor for string-based version initialization
+        public GDKSemVer(string version)
+        {
+            // Default values
+            major = 0;
+            minor = 0;
+            patch = 0;
+            extra = -1;
+
+            if (string.IsNullOrEmpty(version)) return;
+
+            Profiler.BeginSample("GDKSemVer()");
+            {
+                version = version.Trim();
+                Match match = VERSION_PATTERN.Match(version);
+                if (!match.Success)
+                {
+                    LogWarning($"[GDKSemVer] Invalid version string: [{version}]");
+                    Profiler.EndSample();
+                    return;
+                }
+
+                // Parse the version components using TryParse for safety
+                major = int.TryParse(match.Groups[1].Value, out int parsedMajor) ? parsedMajor : 0;
+                minor = int.TryParse(match.Groups[2].Value, out int parsedMinor) ? parsedMinor : 0;
+                if (match.Groups.Count > 3 && !int.TryParse(match.Groups[3].Value, out patch))
+                {
+                    patch = 0;
+                }
+                if (match.Groups.Count > 4 && !int.TryParse(match.Groups[4].Value, out extra))
+                {
+                    extra = -1;
+                }
+            }
+            Profiler.EndSample();
+        }
+
+        // Property to check if the version is valid
+        public bool isValid => this != ZERO;
+
+        // Convert the version to a string representation
+        public override string ToString()
+        {
+            if (this == ZERO) return "-";
+            return extra != -1 ? $"{major}.{minor}.{patch}.{extra}" : $"{major}.{minor}.{patch}";
+        }
+        
+        // Compare this version to another version
+        public int CompareTo(GDKSemVer other)
+        {
+            if (!isValid && !other.isValid) return 0;
+            if (!isValid) return -1;
+            if (!other.isValid) return 1;
+            
+            if (major != other.major) return major.CompareTo(other.major);
+            if (minor != other.minor) return minor.CompareTo(other.minor);
+            if (patch != other.patch) return patch.CompareTo(other.patch);
+            if (extra != other.extra) return extra.CompareTo(other.extra);
+            return 0;
+        }
+
+        public int Compare(GDKSemVer x, GDKSemVer y)
+        {
+            return x.CompareTo(y);
+        }
+
+        // Check if this version is equal to another version
+        public override bool Equals(object obj)
+        {
+            return obj is GDKSemVer other &&
+                   major == other.major &&
+                   minor == other.minor &&
+                   patch == other.patch &&
+                   extra == other.extra;
+        }
+
+        // Equality operators
+        public static bool operator ==(GDKSemVer x, GDKSemVer y)
+        {
+            return x.Equals(y);
+        }
+
+        public static bool operator !=(GDKSemVer x, GDKSemVer y)
+        {
+            return !x.Equals(y);
+        }
+
+        // Comparison operators
+        public static bool operator >(GDKSemVer x, GDKSemVer y)
+        {
+            return x.CompareTo(y) > 0;
+        }
+
+        public static bool operator <(GDKSemVer x, GDKSemVer y)
+        {
+            return x.CompareTo(y) < 0;
+        }
+
+        public static bool operator >=(GDKSemVer x, GDKSemVer y)
+        {
+            return x.CompareTo(y) >= 0;
+        }
+
+        public static bool operator <=(GDKSemVer x, GDKSemVer y)
+        {
+            return x.CompareTo(y) <= 0;
+        }
+
+        // Generate a hash code for the version
+        public override int GetHashCode()
+        {
+            unchecked // Allow overflow
+            {
+                var hash = 17;
+                hash = hash * 23 + major.GetHashCode();
+                hash = hash * 23 + minor.GetHashCode();
+                hash = hash * 23 + patch.GetHashCode();
+                hash = hash * 23 + extra.GetHashCode();
+                return hash;
+            }
+        }
+    }
+}

package/Runtime/Internal/AmaGDK.Internal.AmaGUI.cs

@@ -187,7 +187,7 @@ namespace Amanotes.Core.Internal
             return true;
         }
         
-        public static void SemVerGUI(string title, SemVer version, Color? color1 = null, Color? color2 = null)
+        public static void SemVerGUI(string title, GDKSemVer version, Color? color1 = null, Color? color2 = null)
         {
             const int TAG_SIZE = 60;
             Rect rect = GUILayoutUtility.GetRect(120, 16f);
@@ -210,13 +210,13 @@ namespace Amanotes.Core.Internal
             GUI.Label(rect1, title, versionStyle);
         }
         
-        public static void DrawVersionTag(SemVer version, bool? isValid = null)
+        public static void DrawVersionTag(GDKSemVer version, bool? isValid = null)
         {
             Rect rect = GUILayoutUtility.GetRect(60f, 60f, 18f, 18f);
             DrawVersionTag(rect, version, isValid);
         }
         
-        public static void DrawVersionTag(Rect rect, SemVer version, bool? isValid = null)
+        public static void DrawVersionTag(Rect rect, GDKSemVer version, bool? isValid = null)
         {
             isValid ??= version.isValid;
             DrawTag(rect, version.ToString(), isValid.Value ? LIGHT_BLUE : LIGHT_GRAY, 0.5f);

package/Runtime/Utils/GDKUtils.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections;
-using System.Threading;
 using UnityEngine;
 using static Amanotes.Core.Internal.Logging;
 
@@ -31,5 +29,15 @@ namespace Amanotes.Core.Internal
         {
             SafeInvoke(() => action?.Invoke(eventObject));
         }
+        
+        public static void ThrowExceptionInEditor<T>(string message, Func<string, T> exceptionCreator) where T: Exception
+        {
+            if (Application.isEditor)
+            {
+                throw exceptionCreator(message);
+            }
+            
+            LogWarning(message);
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.65-4",
+    "version": "0.2.65-5",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",

package/Runtime/Internal/AmaGDK.Event.cs

@@ -1,185 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using UnityEngine;
-
-namespace Amanotes.Core
-{
-    public partial class AmaGDK
-    {
-        internal static readonly Dispatcher dispatcher = new Dispatcher();
-        
-        internal static void ThrowExceptionInEditor<T>(string message, Func<string, T> exceptionCreator) where T: Exception
-        {
-            #if UNITY_EDITOR
-            throw exceptionCreator(message);
-            #else
-            Debug.LogWarning(message);
-            #endif
-        }
-        
-        [Serializable] internal class EventEntry
-        {
-            public int nParams;
-            internal bool _dispatching;
-            public Delegate callbacks;
-            public Delegate callbackOnce;
-
-            public bool hasCallback => callbacks != null || callbackOnce != null;
-            
-            internal void Add(Delegate d, bool once)
-            {
-                callbackOnce = Delegate.Remove(callbackOnce, d);
-                callbacks = Delegate.Remove(callbacks, d);
-                if (once)
-                {
-                    callbackOnce = Delegate.Combine(callbackOnce, d);
-                }
-                else
-                {   
-                    callbacks = Delegate.Combine(callbacks, d);
-                }
-            }
-
-            internal void Remove(Delegate d)
-            {
-                callbackOnce = Delegate.Remove(callbackOnce, d);
-                callbacks = Delegate.Remove(callbacks, d);
-            }
-
-            
-
-            internal bool Dispatch(string eventName, object[] args)
-            {
-                if (_dispatching)
-                {
-                    ThrowExceptionInEditor($"Nested dispatching is not supported, eventName: <{eventName}>",
-                        (m) => new InvalidOperationException(m));
-                    return false;
-                }
-                
-                if (args.Length != nParams)
-                {
-                    ThrowExceptionInEditor($"Dispatch <{eventName}> with incorrect number of params, expecting {nParams}, got {args.Length}!",
-                        (m) => new TargetParameterCountException(m));
-                    return false;
-                }
-                
-                _dispatching = true;
-                callbacks?.DynamicInvoke(args);
-                callbackOnce?.DynamicInvoke(args);
-                callbackOnce = null;
-                _dispatching = false;
-
-                return true;
-            }
-        }
-
-        internal class Dispatcher
-        {
-            internal readonly Dictionary<string, EventEntry> _eventMap = new Dictionary<string, EventEntry>();
-            internal void ClearAndReset()
-            {
-                _eventMap.Clear();
-            }
-            
-            internal EventEntry Get(string eventName)
-            {
-                if (string.IsNullOrEmpty(eventName)) return null;
-                _eventMap.TryGetValue(eventName, out EventEntry entry);
-                return entry;
-            }
-
-            internal void AddListener(string eventName, Delegate d, bool once)
-            {
-                if (d == null)
-                {
-                    Debug.LogWarning("Dispatcher.Add() error: d == null");
-                    return;
-                }
-
-                int nParams = d.Method.GetParameters().Length;
-                EventEntry entry = Get(eventName);
-
-                if (entry == null)
-                {
-                    entry = new EventEntry { nParams = nParams };
-                    _eventMap.Add(eventName, entry);
-                }
-                else if (nParams != entry.nParams)
-                {
-                    ThrowExceptionInEditor(string.Format(Internal.Messsage.DISPATCHER_WRONG_NUMBER_OF_PARAMS, eventName, entry.nParams, nParams),
-                        (m) => new TargetParameterCountException(m));
-                    return;
-                }
-                
-                // Debug.Log("Add: " + eventName + " --> " + d + " | " + once);
-                entry.Add(d, once);
-            }
-
-            internal void RemoveListener(string eventName, Delegate d)
-            {
-                if (d == null)
-                {
-                    Debug.LogWarning("Dispatcher.Remove() error: d == null");
-                    return;
-                }
-
-                EventEntry entry = Get(eventName);
-                entry?.Remove(d);
-            }
-            
-            internal void ClearListeners(string eventName)
-            {
-                if (_eventMap.ContainsKey(eventName)) _eventMap.Remove(eventName);
-            }
-
-            internal void Dispatch(string eventName, params object[] data)
-            {
-                if (string.IsNullOrEmpty(eventName))
-                {
-                    ThrowExceptionInEditor(
-                        $"Invalid eventName: <{eventName}> (should not be null or empty)", 
-                        (m)=> new ArgumentException(m));
-                    return;
-                }
-                
-                EventEntry entry = Get(eventName);
-                if (entry == null) return;
-                
-                if (!entry.hasCallback)
-                {
-                    // string[] result = _eventMap
-                    //     .Select(kvp => kvp.Key + ":" + kvp.Value + "\n")
-                    //     .ToArray();
-                    //
-                    // Debug.LogWarning("AmaGDK [Event] No listener of type <" + eventName + ">\n\nRegistered events:\n\n" + string.Join("", result));
-                    return;
-                }
-
-                TryCatchWrapper(() =>
-                {
-                    entry.Dispatch(eventName, data);
-                }, !Application.isEditor);
-            }
-
-            internal static void TryCatchWrapper(Action action, bool useTryCatch)
-            {
-                if (!useTryCatch)
-                {
-                    action();
-                    return;
-                }
-
-                try
-                {
-                    action();
-                } catch (Exception e)
-                {
-                    Debug.LogWarning(e);
-                }
-            }
-        }
-    }
-}

package/Runtime/Internal/AmaGDK.Event.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: b03cd92a98d340e0afed1f2e620fbc2c
-timeCreated: 1705375398

package/Runtime/Internal/AmaGDK.Internal.SemVer.cs

@@ -1,147 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text.RegularExpressions;
-using UnityEngine;
-using UnityEngine.Profiling;
-using static Amanotes.Core.Internal.Logging;
-
-namespace Amanotes.Core.Internal
-{
-    public struct SemVer : IComparable<SemVer>, IComparer<SemVer>
-    {
-        public static readonly SemVer ZERO = new SemVer(0, 0, 0);
-        private static readonly Regex VERSION_PATTERN = new Regex(@"^(\d+)\.(\d+)(?:\.(\d+))?(?:\.(\d+))?$");
-
-        public int major;
-        public int minor;
-        public int patch;
-        public int extra;
-
-        public SemVer(int major, int minor, int patch, int extra = -1)
-        {
-            this.major = major;
-            this.minor = minor;
-            this.patch = patch;
-            this.extra = extra;
-        }
-
-        public SemVer(string version)
-        {
-            major = 0;
-            minor = 0;
-            patch = 0;
-            extra = -1;
-
-            if (string.IsNullOrEmpty(version)) return;
-            
-            Profiler.BeginSample("AmaGDK.SemVer()");
-            {
-                version = version.Trim();
-                Match match = VERSION_PATTERN.Match(version);
-                if (!match.Success)
-                {
-                    LogWarning($"Invalid SemVer string: [{version}]");
-                    Profiler.EndSample();
-                    return;
-                }
-                major = int.Parse(match.Groups[1].Value);
-                minor = int.Parse(match.Groups[2].Value);
-                if (match.Groups.Count > 2)
-                {
-                    if (!int.TryParse(match.Groups[3].Value, out patch))
-                    {
-                        patch = 0;
-                    }
-                }
-                if (match.Groups.Count > 3)
-                {
-                    if (!int.TryParse(match.Groups[4].Value, out extra))
-                    {
-                        extra = -1;
-                }
-            }
-            }
-            Profiler.EndSample();
-        }
-
-        public bool isValid => this != ZERO;
-
-        public override string ToString()
-        {
-            if (this == ZERO) return "-";
-            if (extra != -1) return $"{major}.{minor}.{patch}.{extra}";
-            return $"{major}.{minor}.{patch}";
-        }
-
-        public int CompareTo(SemVer other)
-        {
-            if (!isValid)
-            {
-                if (!other.isValid)
-                {
-                    return 0;
-                }
-                return -1;
-            }
-
-            if (!other.isValid)
-            {
-                return 1;
-            }
-            
-            
-            if (major != other.major) return major.CompareTo(other.major);
-            if (minor != other.minor) return minor.CompareTo(other.minor);
-            if (patch != other.patch) return patch.CompareTo(other.patch);
-            if (extra != other.extra) return extra.CompareTo(other.extra);
-            return 0;
-        }
-
-        public int Compare(SemVer x, SemVer y)
-        {
-            return x.CompareTo(y);
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (!(obj is SemVer)) return false;
-            var other = (SemVer)obj;
-            return major == other.major && minor == other.minor && patch == other.patch && extra == other.extra;
-        }
-
-        public static bool operator >(SemVer x, SemVer y)
-        {
-            return x.CompareTo(y) > 0;
-        }
-
-        public static bool operator <(SemVer x, SemVer y)
-        {
-            return x.CompareTo(y) < 0;
-        }
-
-        public static bool operator >=(SemVer x, SemVer y)
-        {
-            return x.CompareTo(y) >= 0;
-        }
-
-        public static bool operator <=(SemVer x, SemVer y)
-        {
-            return x.CompareTo(y) <= 0;
-        }
-
-        public static bool operator ==(SemVer x, SemVer y)
-        {
-            return x.Equals(y);
-        }
-
-        public static bool operator !=(SemVer x, SemVer y)
-        {
-            return !x.Equals(y);
-        }
-
-        public override int GetHashCode()
-        {
-            return (major << 24) | (minor << 16) | (patch << 8) | extra;
-        }
-    }
-}