com.amanotes.gdk 0.2.48 → 0.2.50

package/Runtime/AmaGDK.cs

@@ -17,18 +17,27 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.48";
+        public const string VERSION = "0.2.50";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;
-        internal static Action _onReadyCallback;
-        internal static Action<string> _onAdapterReadyCallback;
         internal static bool _allowInit = false;
         public bool autoInit = true;
 
         private static ConfigAsset _config = null;
-        // private static readonly Dictionary<string, AdapterInfo> _adapters = new Dictionary<string, AdapterInfo>();
-
+        
+        public static partial class Event
+        {
+            public const string GDK_HOOK_START = nameof(GDK_HOOK_START);
+            public const string GDK_HOOK_END = nameof(GDK_HOOK_END);
+            
+            public const string GDK_INIT_START = nameof(GDK_INIT_START);
+            public const string GDK_INIT_END = nameof(GDK_INIT_END);
+            
+            public const string GDK_READY = nameof(GDK_READY);
+            public const string ADAPTER_READY = nameof(ADAPTER_READY);
+        }
+        
         public static ConfigAsset Config
         {
             get
@@ -42,15 +51,17 @@ namespace Amanotes.Core
 
         private void Awake()
         {
-            if (_instance != null && _instance != this)
+            if (_instance != null)
             {
-                LogWarning(MULTIPLE_INSTANCE);
-                Destroy(this);
+                if (_instance != this)
+                {
+                    LogWarning(MULTIPLE_INSTANCE);
+                    Destroy(this);    
+                }
+                LogWarning("Should never be here!");
                 return;
             }
-
-            if (_instance != null) LogWarning("Should never be here!");
-
+            
             _instance = this;
             DontDestroyOnLoad(this);
             
@@ -60,10 +71,12 @@ namespace Amanotes.Core
         
         IEnumerator InitHook()
         {
+            dispatcher.Dispatch(Event.GDK_HOOK_START);
             int nHooks = Hook.hooks.Count;
             if (nHooks == 0)
             {
                 Log($"[Hook] No hook registered!");
+                dispatcher.Dispatch(Event.GDK_HOOK_END);
                 yield break;
             }
             
@@ -71,7 +84,6 @@ namespace Amanotes.Core
             var hookCompleted = false;
             
             float stTime = Time.realtimeSinceStartup;
-            
             Hook.TriggerHooks(() =>
             {
                 hookCompleted = true;
@@ -79,6 +91,7 @@ namespace Amanotes.Core
             yield return new WaitUntil(() => hookCompleted);
             float elapsed = Time.realtimeSinceStartup - stTime;
             Log($"[Hook] {nHooks} hooks complete after " + elapsed);
+            dispatcher.Dispatch(Event.GDK_HOOK_END);
         }
         
         IEnumerator WaitForManualInit()
@@ -106,7 +119,8 @@ namespace Amanotes.Core
                 User.InitModule();
                 Analytics.InitModule();
                 Ads.InitModule();
-                IAP.InitModule();    
+                IAP.InitModule();
+                RemoteConfig.InitModule();
             }
             Profiler.EndSample();
         }
@@ -119,6 +133,7 @@ namespace Amanotes.Core
                 Analytics.StartModule();
                 Ads.StartModule();
                 IAP.StartModule();
+                RemoteConfig.StartModule();
             }
             Profiler.EndSample();
         }
@@ -137,9 +152,9 @@ namespace Amanotes.Core
             {
                 // Log($"Initiating {adapter.adapterId} --> initOrder: {adapter.initOrder} | {adapter.status}");
                 float startTime = Time.realtimeSinceStartup;
-                Profiler.BeginSample("AmaGDK.adapter.InitSDK()");
+                Profiler.BeginSample($"AmaGDK.adapter.InitSDK-{adapter.adapterId}");
                 {
-                    adapter.InitSDK();    
+                    adapter.InitSDK();
                 }
                 Profiler.EndSample();
                 
@@ -150,13 +165,12 @@ namespace Amanotes.Core
                     LogWarning($"{adapter.adapterId} init time out: {TIMEOUT}");
                 }
 
-                _onAdapterReadyCallback?.Invoke(adapter.adapterId);
+                dispatcher.Dispatch(Event.ADAPTER_READY, adapter.adapterId);
                 sb.AppendLine($"[{(adapter.IsReady ? " OK " : "FAIL")}] {adapter.adapterId} (~ {Time.realtimeSinceStartup - startTime:#0.00}s)");
                 
                 // Wait for postprocessing of each adapter
                 yield return null;
             }
-            _onAdapterReadyCallback = null;
         }
         
         
@@ -170,6 +184,7 @@ namespace Amanotes.Core
             float startTime = Time.realtimeSinceStartup;
             yield return InitHook();
             
+            dispatcher.Dispatch(Event.GDK_INIT_START);
             var sb = new StringBuilder();
             InitModules();
             
@@ -177,10 +192,10 @@ namespace Amanotes.Core
             yield return InitAdapters(sb);
             
             StartModules();
+            dispatcher.Dispatch(Event.GDK_INIT_END);
             
             _status = Status.Ready;
-            _onReadyCallback?.Invoke();
-            _onReadyCallback = null;
+            dispatcher.Dispatch(Event.GDK_READY);
             Debug.Log($"AmaGDK v{VERSION} | {READY} in {Time.realtimeSinceStartup - startTime:#0.00}s\n\n{sb}");
         }
     }
@@ -200,8 +215,7 @@ namespace Amanotes.Core
 
             if (onReady != null)
             {
-                _onReadyCallback -= onReady;
-                _onReadyCallback += onReady;
+                dispatcher.AddListener(Event.GDK_READY, onReady, true);
             }
 
             if (_allowInit)
@@ -211,28 +225,21 @@ namespace Amanotes.Core
             }
 
             _allowInit = true;
-
             if (_instance != null) return;
+            
             var sdk = new GameObject("AmaGDK");
             _instance = sdk.AddComponent<AmaGDK>();
         }
 
         public static void SetOnReadyCallback(Action onReady)
         {
-            if (onReady == null)
-            {
-                LogWarning("Cannot add a null callback!");
-                return;
-            }
-
             if (isReady)
             {
                 onReady.Invoke();
                 return;
             }
             
-            _onReadyCallback -= onReady;
-            _onReadyCallback += onReady;
+            dispatcher.AddListener(Event.GDK_READY, onReady, true);
         }
 
         public static void SetAdapterReadyCallback(Action<string> onAdapterReady)
@@ -242,11 +249,15 @@ namespace Amanotes.Core
                 LogWarning("Cannot add a null callback!");
                 return;
             }
+
+            if (AmaGDK.isReady)
+            {
+                LogWarning("All adapters has been init / ready!");
+                return;
+            }
             
-            _onAdapterReadyCallback -= onAdapterReady;
-            _onAdapterReadyCallback += onAdapterReady;
+            dispatcher.AddListener(Event.ADAPTER_READY, onAdapterReady, false);
         }
-
     }
 
     public partial class AmaGDK
@@ -316,7 +327,7 @@ namespace Amanotes.Core
                 return;
             }
         
-            int startIndex = zshrcContent.IndexOf($"export {variableName}=");
+            int startIndex = zshrcContent.IndexOf($"export {variableName}=", StringComparison.Ordinal);
             if (startIndex >= 0)
             {
                 startIndex += $"export {variableName}=".Length;
@@ -366,7 +377,7 @@ namespace Amanotes.Core
         #endif
     }
 
-    public partial class AmaGDK // Switch dev mode
+    public partial class AmaGDK
     {
         public static class Hook
         {

package/Runtime/Internal/AmaGDK.Event.cs

@@ -0,0 +1,185 @@
+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

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

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -26,6 +26,8 @@ namespace Amanotes.Core.Internal
         public const string SDK_INIT_CALLED = "init has been called!";
         public const string MULTIPLE_INSTANCE = "multiple instance found!";
         public const string CONFIG_NOT_FOUND = "AmaGDKConfig not found in Resources!";
+        public const string DISPATCHER_WRONG_NUMBER_OF_PARAMS = "AddListener for eventName <{0}> expect {1} params but got {2}";
+        
     }
 
     public static class Res
@@ -37,6 +39,7 @@ namespace Amanotes.Core.Internal
 #endif
 
         public const string PACKAGE_PATH = BASE_PATH + "Packages/";
+        public const string EXTRA_PATH = BASE_PATH + "Extra/";
         public const string AMAGDK_PREFAB = BASE_PATH + "Runtime/AmaGDK.prefab";
         public const string AMAGDK_CONFIG_PACKAGE = PACKAGE_PATH + "AmaGDKConfig.unitypackage";
 
@@ -124,6 +127,7 @@ namespace Amanotes.Core.Internal
             // Reset all modules
             Ads.context = null;
             Ads._adapter = null;
+            dispatcher.ClearAndReset();
             
             _status = Status.None;
             _allowInit = false;

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -66,6 +66,56 @@ namespace Amanotes.Core.Internal
                 if (Time.realtimeSinceStartup - time > timeoutInSecs) yield break;
             }
         }
+        
+        
+        public static bool IsFromTemplate(string formattedString, string template)
+        {
+            // Split the original template into segments based on the positions of placeholders
+            string[] segments = SplitTemplate(template);
+
+            // Check if each segment exists in the output string in the correct order
+            return AreSegmentsPresentInOrder(segments, formattedString);
+        }
+
+        static bool AreSegmentsPresentInOrder(string[] segments, string outputString)
+        {
+            var lastIndex = 0;
+
+            // Check if each segment exists in the output string in the correct order
+            foreach (string segment in segments)
+            {
+                int index = outputString.IndexOf(segment, lastIndex, StringComparison.Ordinal);
+
+                if (index == -1) return false;
+                lastIndex = index + segment.Length;
+            }
+
+            return true;
+        }
+
+        static string[] SplitTemplate(string template)
+        {
+            // Create a regex pattern to match placeholders like {0}, {1}, {2}, etc.
+            var pattern = @"\{(\d+)\}";
+
+            // Extract the indexes of placeholders from the original template
+            MatchCollection matches = Regex.Matches(template, pattern);
+
+            // Split the original template into segments based on the matched indexes
+            var segments = new string[matches.Count + 1];
+            var lastIndex = 0;
+
+            foreach (Match match in matches)
+            {
+                int index = int.Parse(match.Groups[1].Value);
+                segments[index] = template.Substring(lastIndex, match.Index - lastIndex);
+                lastIndex = match.Index + match.Length;
+            }
+
+            // The last segment corresponds to the content after the last placeholder
+            segments[matches.Count] = template.Substring(lastIndex);
+            return segments;
+        }
     }
     
     public static class GDKReflection
@@ -87,8 +137,8 @@ namespace Amanotes.Core.Internal
         }
         
     }
-    
-    internal static class GDKFileUtils
+
+    public static class GDKFileUtils
     {
         private static string _basePath;
         private static string basePath
@@ -115,7 +165,7 @@ namespace Amanotes.Core.Internal
             return File.Exists(GetPath(fileName));
         }
 
-        internal static void Save(string fileName, string content)
+        public static void Save(string fileName, string content)
         {
             if (string.IsNullOrWhiteSpace(fileName))
             {
@@ -188,7 +238,7 @@ namespace Amanotes.Core.Internal
             }
         }
 
-        internal static string Load(string fileName)
+        public static string Load(string fileName)
         {
             var content = "";
 
@@ -247,6 +297,33 @@ namespace Amanotes.Core.Internal
             }
             Debug.Log(sb);
         }
+        
+        public static T LoadJsonFromFile<T>(T instance) where T: new()
+        {
+            instance ??= new T();
+            
+            string fileName = instance.GetType().Name;
+            string json = Load(fileName);
+            if (!string.IsNullOrEmpty(json))
+            {
+                try
+                {
+                    JsonUtility.FromJsonOverwrite(json, instance);
+                } catch (Exception e)
+                {
+                    LogWarning("LoadJsonFromFile error: " + fileName + "\n" + e);
+                }
+            }
+            
+            return instance;
+        }
+
+        public static void SaveJsonToFile<T>(T instance)
+        {
+            string fileName = instance.GetType().Name;
+            string json = JsonUtility.ToJson(instance);
+            Save(fileName, json);
+        }
     }
 
     public class ActionQueue
@@ -313,34 +390,18 @@ namespace Amanotes.Core.Internal
     }
 
     internal interface IJsonFile { }
+    
 
     internal static class JsonFileExtension
     {
         public static T LoadJsonFromFile<T>(this T instance) where T : IJsonFile, new()
         {
-            instance ??= new T();
-            
-            string fileName = instance.GetType().Name;
-            string json = GDKFileUtils.Load(fileName);
-            if (!string.IsNullOrEmpty(json))
-            {
-                try
-                {
-                    JsonUtility.FromJsonOverwrite(json, instance);
-                } catch (Exception e)
-                {
-                    LogWarning("LoadJsonFromFile error: " + fileName + "\n" + e);
-                }
-            }
-            
-            return instance;
+            return GDKFileUtils.LoadJsonFromFile(instance);
         }
 
-        public static void SaveJsonToFile<T>(this T instance) where T : IJsonFile
+        public static void SaveJsonToFile<T>(this T instance) where T: IJsonFile
         {
-            string fileName = instance.GetType().Name;
-            string json = JsonUtility.ToJson(instance);
-            GDKFileUtils.Save(fileName, json);
+            GDKFileUtils.SaveJsonToFile(instance);
         }
     }
 

package/Runtime/Klavar/Attributes.meta

@@ -1,9 +1,5 @@
 fileFormatVersion: 2
-<<<<<<<< HEAD:GDK/AmaGDKCore/Runtime/Klavar/Attributes.meta
 guid: 74f302749097e44ff889ed117ec82dd3
-========
-guid: 2fdae68db26424f679091198f471cf00
->>>>>>>> fafdc57 ([Release] 0.2.47):GDKTest/GDK-Unity2020.3/Assets/AmaGDKTest.meta
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/Klavar.meta

@@ -1,9 +1,5 @@
 fileFormatVersion: 2
-<<<<<<<< HEAD:GDK/AmaGDKCore/Runtime/Klavar.meta
 guid: 5b981038cfa6f4ec2a7dd96f58fde6cd
-========
-guid: 74f302749097e44ff889ed117ec82dd3
->>>>>>>> fafdc57 ([Release] 0.2.47):GDK/AmaGDKCore/Runtime/Klavar/Attributes.meta
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/package.json

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