com.amanotes.gdk 0.2.63 → 0.2.65-1

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -87,12 +87,13 @@ namespace Amanotes.Core.Internal
         public static void LogError(string message)
         {
             if (Config.common.logLevel >= LogLevel.Error) Debug.LogError($"AmaGDK {message}");
-            if (logNonfatalErrorHook != null)
+            if (logNonfatalErrorHook == null) return;
+            GDKUtils.DoOnMainThread(() =>
             {
                 if (nonFatalDict.Contains(message)) return; // LogOnce
                 nonFatalDict.Add(message);
-                logNonfatalErrorHook(message);
-            }
+                logNonfatalErrorHook(message);    
+            });
         }
         public static void Log(string message)
         {
@@ -184,11 +185,6 @@ namespace Amanotes.Core.Internal
         }
     }
     
-    public interface IOnApplicationPause { void OnApplicationPause(bool pauseStatus); }
-    public interface IOnApplicationQuit { void OnApplicationQuit(); }
-    public interface IOnApplicationFocus { void OnApplicationFocus(bool hasFocus); }
-    public interface IOnFrameUpdate { void OnFrameUpdate(); }
-
     public static class Utils // Hidden Utils
     {
         private static readonly Dictionary<string, float> LastFireInSessions = new Dictionary<string, float>();

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -12,61 +12,8 @@ using static Amanotes.Core.Internal.Logging;
 
 namespace Amanotes.Core.Internal
 {
-    public static class GDKUtils
+    public static partial class GDKUtils
     {
-        public static void DelayCall(float seconds, Action action)
-        {
-            AmaGDK._instance.StartCoroutine(DelayCallRoutine(seconds, action));
-        }
-        
-        public static void RegisterUnityCallbacks<T>(T target)
-        {
-            if (target == null)
-            {
-                LogWarning("RegisterUnityCallbacks: Target is null!");
-                return;
-            }
-            
-            if (target is IOnFrameUpdate u)
-            {
-                AmaGDK.onFrameUpdate -= u.OnFrameUpdate;
-                AmaGDK.onFrameUpdate += u.OnFrameUpdate;
-            }
-
-            if (target is IOnApplicationPause p)
-            {
-                AmaGDK.onApplicationPause -= p.OnApplicationPause;
-                AmaGDK.onApplicationPause += p.OnApplicationPause;
-            }
-            
-            if (target is IOnApplicationFocus f)
-            {
-                AmaGDK.applicationFocus -= f.OnApplicationFocus;
-                AmaGDK.applicationFocus += f.OnApplicationFocus;
-            }
-            
-            if (target is IOnApplicationQuit q)
-            {
-                AmaGDK.applicationQuit -= q.OnApplicationQuit;
-                AmaGDK.applicationQuit += q.OnApplicationQuit;
-            }
-        }
-
-        private static IEnumerator DelayCallRoutine(float seconds, Action callback)
-        {
-            yield return new WaitForSecondsRealtime(seconds);
-            callback();
-        }
-        
-        public static IEnumerator Timeout(float timeoutInSecs, Func<bool> completeCheckFunc)
-        {
-            float time = Time.realtimeSinceStartup;
-            while (completeCheckFunc() == false)
-            {
-                yield return null;
-                if (Time.realtimeSinceStartup - time > timeoutInSecs) yield break;
-            }
-        }
         
         
         public static bool IsFromTemplate(string formattedString, string template)
@@ -153,7 +100,7 @@ namespace Amanotes.Core.Internal
             segments[matches.Count] = template.Substring(lastIndex);
             return segments;
         }
-
+        
         internal static void ThrowIf(bool condition, string message)
         {
             if (condition)
@@ -321,7 +268,7 @@ namespace Amanotes.Core.Internal
             }
         }
         
-        internal static void ClearCacheData()
+        public static void ClearCacheData()
         {
             var sb = new StringBuilder();
             sb.AppendLine("[AmaGDK] All cached data & stats cleared");

package/Runtime/Internal/HideInNormalInspectorAttribute.cs

@@ -0,0 +1,9 @@
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public class HideInNormalInspectorAttribute : PropertyAttribute 
+    {
+        public HideInNormalInspectorAttribute() { }
+    }
+}

package/Runtime/Internal/HideInNormalInspectorAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 988f818f8951413e9813008614e04a4a
+timeCreated: 1717410575

package/Runtime/Klavar/Attributes/AccumulatedCountAttribute.cs

@@ -16,5 +16,4 @@ namespace Amanotes.Core
             return AmaGDK.Analytics.GetAccumulatedCount(attr.name) + 1;
         }
     }
-    public class LifetimeCountAttribute : AccumulatedCountAttribute { }
 }

package/Runtime/Klavar/Attributes/MinMaxAttribute.cs

@@ -1,128 +1,135 @@
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 
 namespace Amanotes.Core
 {
+    
+    internal static class NumericValidationHelper
+    {
+        private static readonly HashSet<Type> NumericTypes = new HashSet<Type> { typeof(int), typeof(float), typeof(double) };
+
+        internal static bool IsNumeric(this object param)
+        {
+            return NumericTypes.Contains(param.GetType());
+        }
+    }
+    
     /// <summary>
     /// Min, Max validate param
     /// </summary>
     public class MinMaxAttribute : ValidateLogEventAttribute
     {
+        private readonly double min;
+        private readonly double max;
+        private readonly bool inclusiveMin;
+        private readonly bool inclusiveMax;
 
-        public readonly double min;
-
-        public readonly double max;
-
-        public MinMaxAttribute(double min, double max)
+        public MinMaxAttribute(double min, double max, bool inclusiveMin = true, bool inclusiveMax = true)
         {
             this.min = min;
             this.max = max;
+            this.inclusiveMin = inclusiveMin;
+            this.inclusiveMax = inclusiveMax;
         }
 
-
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (!(param is int) && !(param is float) && !(param is double))
-                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+            if (param == null)
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must not be null.");
+                return;
+            }
+
+            if (!param.IsNumeric())
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Type of '{fieldInfo.Name}' must be int, float, or double.");
+                return;
+            }
 
             double val = Convert.ToDouble(param);
-            if (val < min) throw new ArgumentException($"Field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current value: {param}");
-            if (val > max) throw new ArgumentException($"Field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current value: {param}");
-        }
-    }
-
-
-    public class MinimumAttribute : ValidateLogEventAttribute
-    {
+            bool isMinValid = inclusiveMin ? val >= min : val > min;
+            bool isMaxValid = inclusiveMax ? val <= max : val < max;
 
-        public readonly double min;
+            if (isMinValid && isMaxValid) return;
 
+            string minBracket = inclusiveMin ? "[" : "(";
+            string maxBracket = inclusiveMax ? "]" : ")";
+            string rangeDescription = $"{minBracket}{min}, {max}{maxBracket}";
 
-        public MinimumAttribute(double min)
-        {
-            this.min = min;
-        }
-
-
-        public override void Validate(object parent, FieldInfo fieldInfo, object param)
-        {
-            if (!(param is int) && !(param is float) && !(param is double))
-                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
-
-            double val = Convert.ToDouble(param);
-            if (val < min) throw new ArgumentException($"Field `{fieldInfo.Name}` must be greater or equal to {min}. Current value: {param}");
+            KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must be in the {rangeDescription}. Current value: {param}");
         }
     }
-
-
-    public class ExclusiveMinimumAttribute : ValidateLogEventAttribute
+    
+    public class MinimumAttribute : ValidateLogEventAttribute
     {
+        private readonly double min;
+        private readonly bool inclusive;
 
-        public readonly double min;
-
-
-        public ExclusiveMinimumAttribute(double min)
+        public MinimumAttribute(double min, bool inclusive = true)
         {
             this.min = min;
+            this.inclusive = inclusive;
         }
-
-
+    
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (!(param is int) && !(param is float) && !(param is double))
-                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+            if (param == null)
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must not be null.");
+                return;
+            }
+            if (!param.IsNumeric())
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Type of '{fieldInfo.Name}' must be int, float, or double.");
+                return;
+            }
 
             double val = Convert.ToDouble(param);
-            if (val <= min) throw new ArgumentException($"Field `{fieldInfo.Name}` must be greater {min}. Current value: {param}");
+            if (inclusive)
+            {
+                if (val < min) KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must be greater than or equal to {min}. Current value: {param}");
+            }
+            else
+            {
+                if (val <= min) KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must be greater than {min}. Current value: {param}");
+            }
         }
     }
-
-
-
-
-
+    
     public class MaximumAttribute : ValidateLogEventAttribute
     {
+        private readonly double max;
+        private readonly bool inclusive;
 
-        public readonly double max;
-
-
-        public MaximumAttribute(double max)
-        {
-            this.max = max;
-        }
-
-
-        public override void Validate(object parent, FieldInfo fieldInfo, object param)
-        {
-            if (!(param is int) && !(param is float) && !(param is double))
-                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
-
-            double val = Convert.ToDouble(param);
-            if (val > max) throw new ArgumentException($"Field `{fieldInfo.Name}` must be smaller or equal to {max}. Current value: {param}");
-        }
-    }
-
-
-    public class ExclusiveMaximumAttribute : ValidateLogEventAttribute
-    {
-
-        public readonly double max;
-
-
-        public ExclusiveMaximumAttribute(double max)
+        public MaximumAttribute(double max, bool inclusive = true)
         {
             this.max = max;
+            this.inclusive = inclusive;
         }
-
-
+    
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (!(param is int) && !(param is float) && !(param is double))
-                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+            if (param == null)
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must not be null.");
+                return;
+            }
+            if (!param.IsNumeric())
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Type of '{fieldInfo.Name}' must be int, float, or double.");
+                return;
+            }
 
             double val = Convert.ToDouble(param);
-            if (val >= max) throw new ArgumentException($"Field `{fieldInfo.Name}` must be smaller to {max}. Current value: {param}");
+            if (inclusive)
+            {
+                if (val > max) KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must be less than or equal to {max}. Current value: {param}");
+            }
+            else
+            {
+                if (val >= max) KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must be less than {max}. Current value: {param}");
+            }
         }
     }
 }

package/Runtime/Klavar/Attributes/MinMaxLengthAttribute.cs

@@ -1,15 +1,15 @@
-using System;
 using System.Reflection;
 
 namespace Amanotes.Core
 {
+    
     /// <summary>
     /// Min, Max length valudate validate param. (Just apply for string only)
     /// </summary>
     public class MinMaxLengthAttribute : ValidateLogEventAttribute
     {
-        public readonly int min;
-        public readonly int max;
+        private readonly int min;
+        private readonly int max;
 
         public MinMaxLengthAttribute(int min, int max)
         {
@@ -17,58 +17,74 @@ namespace Amanotes.Core
             this.max = max;
         }
 
-
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
-            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
-            if (text.Length < min) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current length: {text.Length}");
-            if (text.Length > max) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current length: {text.Length}");
+            if (param is string text)
+            {
+                if (text.Length >= min && text.Length <= max) return;
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"The length of string field '{fieldInfo.Name}' must be between {min} and {max} (inclusive). Current length: {text.Length}");
+            }
+            else
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, param is null ? $"Field {fieldInfo.Name} must not be null." : $"Field {fieldInfo.Name} must be a string.");
+            }
         }
     }
-
-
+    
     public class MinLengthAttribute : ValidateLogEventAttribute
     {
-        public readonly int min;
+        private readonly int min;
 
         public MinLengthAttribute(int min)
         {
             this.min = min;
         }
 
-
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
-            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
-            if (text.Length < min) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be greater or equal to {min}. Current length: {text.Length}");
+            if (param is string text)
+            {
+                if (text.Length < min)
+                {
+                    KlavarException.ThrowErrorOnField(parent, fieldInfo, $"The length of string field '{fieldInfo.Name}' must be greater than or equal to {min}. Current length: {text.Length}");
+                }
+            }
+            else
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, param is null ? $"Field {fieldInfo.Name} must not be null." : $"Field {fieldInfo.Name} must be a string.");
+            }
         }
     }
 
-
     public class MaxLengthAttribute : ValidateLogEventAttribute
     {
-        public readonly int max;
+        private readonly int max;
 
         public MaxLengthAttribute(int max)
         {
             this.max = max;
         }
 
-
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
-            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
-            if (text.Length > max) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be smaller or equal to {max}. Current length: {text.Length}");
+            if (param is string text)
+            {
+                if (text.Length > max)
+                {
+                    KlavarException.ThrowErrorOnField(parent, fieldInfo, $"The length of string field '{fieldInfo.Name}' must be less than or equal to {max}. Current length: {text.Length}");
+                }
+            }
+            else
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, param is null ? $"Field {fieldInfo.Name} must not be null." : $"Field {fieldInfo.Name} must be a string.");
+            }
         }
     }
 
 
     public class FixedLengthAttribute : ValidateLogEventAttribute
     {
-        public readonly int length;
+        private readonly int length;
 
         public FixedLengthAttribute(int length)
         {
@@ -77,10 +93,15 @@ namespace Amanotes.Core
 
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
-            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
-            if (text.Length != length)
-                throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be equal to {length}. Current length: {text.Length}");
+            if (param is string text)
+            {
+                if (text.Length != length)
+                    KlavarException.ThrowErrorOnField(parent, fieldInfo,$"The length of string field '{fieldInfo.Name}' must be equal to {length}. Current length: {text.Length}");
+            }
+            else
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, param is null ? $"Field {fieldInfo.Name} must not be null." : $"Field {fieldInfo.Name} must be string.");
+            }
         }
     }
 }

package/Runtime/Klavar/Attributes/NotNullAttribute.cs

@@ -10,7 +10,7 @@ namespace Amanotes.Core
     {
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (param is null) throw new ArgumentException($"Field `{fieldInfo.Name}` must not be null");
+            if (param is null) KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must not be null");
         }
     }
 }

package/Runtime/Klavar/Attributes/RegexPatternAttribute.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using System.Reflection;
 using System.Text.RegularExpressions;
 
@@ -18,23 +19,25 @@ namespace Amanotes.Core
         {
             this.regexes = new string[] { regex };
         }
-
-
+        
         public RegexPatternAttribute(string[] regexes)
         {
             this.regexes = regexes;
         }
 
-
         public override void Validate(object parent, FieldInfo fieldInfo, object param)
         {
-            if (param is null) throw new ArgumentException($"Field `{fieldInfo.Name}` must not be null");
-            foreach (var regex in regexes)
+            if (param is null)
+            {
+                KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' must not be null");
+                return;
+            }
+            foreach (string regex in regexes)
             {
                 var match = Regex.Match(param.ToString(), regex);
-                if (match != null && match.Success) return;
+                if (match.Success) return;
             }
-            throw new ArgumentException($"Field `{fieldInfo.Name}` is not match as {this.GetType().Name.Replace("Attribute", "")}");
+            KlavarException.ThrowErrorOnField(parent, fieldInfo, $"Field '{fieldInfo.Name}' is not match as {this.GetType().Name.Replace("Attribute", "")}");
         }
     }
 

package/Runtime/Klavar/Attributes/ToStringAttribute.cs

@@ -63,7 +63,7 @@ namespace Amanotes.Core
 
         public override object Convert(object parent, FieldInfo fieldInfo, object param)
         {
-            return GetValueAsString(param);
+            return param is null ? null : GetValueAsString(param);
         }
     }
 

package/Runtime/Klavar/KlavarContainer.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Reflection;
 using Amanotes.Core.Internal;
 using UnityEngine;
 using GUID = System.Guid;
@@ -13,11 +14,7 @@ namespace Amanotes.Core
 
         public static void LogEventError(string message)
         {    
-            #if UNITY_EDITOR
-            throw new KlavarException(message);
-            #else
-            Logging.LogError(message);
-            #endif
+            KlavarException.ThrowIfEditor(message);
         }
     }
 
@@ -25,6 +22,25 @@ namespace Amanotes.Core
     {
         public KlavarException() { }
         public KlavarException(string message) : base(message) { }
+
+        public static void ThrowIfEditor(string message)
+        {
+            #if UNITY_EDITOR
+            throw new KlavarException(message);
+            #else
+            Logging.LogError(message);
+            #endif
+        }
+
+        public static void ThrowErrorOnField(object parent, FieldInfo fieldInfo, string message)
+        {
+            var classType = parent.GetType();
+            var eventNameAttr = (EventNameAttribute) Attribute.GetCustomAttribute(classType, typeof(EventNameAttribute), true);
+            string eventName = eventNameAttr?.name ?? classType.Name;
+            var paramNameAttr = fieldInfo.GetCustomAttribute<NameAttribute>(true);
+            string paramName = paramNameAttr?.name ?? fieldInfo.Name;
+            ThrowIfEditor($"Error at event '{eventName}' parameter '{paramName}': {message}");
+        }
     }
 }
 

package/Runtime/Klavar/KlavarEvent.cs

@@ -23,7 +23,10 @@ namespace Amanotes.Core
             var eventNameAttr = (EventNameAttribute)Attribute.GetCustomAttribute(type, typeof(EventNameAttribute));
 
             if (eventNameAttr == null)
-                throw new ArgumentException($"Add `EventName` attribute to class {type.FullName}");
+            {
+                KlavarException.ThrowIfEditor($"Add `EventName` attribute to class {type.FullName}");
+                return;
+            }
             
             var @params = this.ToDict();
             var eventName = eventNameAttr.name;

package/Runtime/Utils/GDKUtils.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections;
+using System.Threading;
+using UnityEngine;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core.Internal
+{
+    public static partial class GDKUtils
+    {
+        public static void SafeInvoke(Action action)
+        {
+            if (action == null) return;
+            
+            if (Application.isEditor)
+            {
+                action.Invoke();
+                return;
+            }
+            
+            try
+            {
+                action.Invoke();
+            } catch (Exception e)
+            {
+                LogError(e.ToString());
+            }
+        }
+        
+        public static void SafeInvoke<T>(Action<T> action, T eventObject)
+        {
+            SafeInvoke(() => action?.Invoke(eventObject));
+        }
+    }
+}

package/Runtime/Utils/GDKUtils.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1f1fd1d7763a459cb601c7ca49c16604
+timeCreated: 1718075573

package/Runtime/Utils.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f98d760a3ec994477a8e8a100e9f9798
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

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