com.amanotes.gdk 0.2.48 → 0.2.49

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
@@ -124,6 +126,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.49",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",