com.amanotes.gdk 0.2.64 → 0.2.65-1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.2.66 - 2024-06-13]
+- [Fix] Missing Google CMP in package release
+
+## [0.2.65 - 2024-06-13]
+- [Dev] Add GDKRoutine
+- [Dev] Add option to preload banners
+- [Fix] Handle GoogleCMP callback in main-thread
+- Also: Ensure Logging.LogError is thead-safe
+- [Fix] Manage banner status so not to request banner load multiple times
+- [Add] GDKUnityCallback with thread-safe
+- [Feature] Add fullads_impression & videoads_impression events for better fill rate tracking
+- [Klavar] Improve parameter validation
+
 ## [0.2.64 - 2024-06-06]
 - [Dev] Log gdk_init
 - [Fix] map_user_id must contain FRB, AF, [GAID, IDFA]

package/Extra/GoogleCMP.unitypackage.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4e220bd58ce0646bcbbb209dc8451d25
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AmaGDK.Adapters.cs

@@ -66,7 +66,7 @@ namespace Amanotes.Core.Internal
             
             adapter.adapterId = id;
             adapter.adapterVersion = version;
-            GDKUtils.RegisterUnityCallbacks(adapter);
+            GDKUtils.AddUnityCallbacks(adapter);
             adapterMap.Add(id, adapter);
             return true;
         }

package/Runtime/AmaGDK.Ads.cs

@@ -275,7 +275,7 @@ namespace Amanotes.Core
                 
                 if (Config.ad.enableInterstitial) _adapter.interstitial.StartLoadAd();
                 if (Config.ad.enableRewarded) _adapter.rewardVideo.StartLoadAd();
-
+                if (Config.ad.preloadBanner) PreloadBanner();
                 if (_isBannerShowing)
                 {
                     _isBannerShowing = false;
@@ -323,6 +323,30 @@ namespace Amanotes.Core
 
             [NonSerialized] private static bool _isBannerShowing = false;
             
+            public static void PreloadBanner()
+            {
+                if (!_config.ad.enableBanner)
+                {
+                    LogWarning($"Banner not enabled! {_config.ad.enableBanner}");
+                    return;
+                }
+                
+                if (_adapter == null)
+                {
+                    LogWarning($"Adapter is null!");
+                    return;
+                }
+                
+                if (_isBannerShowing)
+                {
+                    LogWarning($"Banner is showing!");
+                    return;
+                }
+                
+                _adapter.ShowBanner();
+                _adapter.HideBanner();
+            }
+            
             public static void ShowBanner()
             {
                 if (!_config.ad.enableBanner)
@@ -426,6 +450,9 @@ namespace Amanotes.Core.Internal
         [Tooltip("Before showing an ad: set Time.timeScale to 0\nAfter the ad is closed: restore the previously saved Time.timeScale")]
         public bool autoTimeScale = true;
 
+        [Tooltip("Preload banner right when Ad module init (default = false)")]
+        public bool preloadBanner = false;
+
         [Header("EDITOR")]
         [Tooltip("Only applicable in Editor\n0 = 0% success\n1 = 100% success")]
         [Range(0f, 1f)] public float rewardAdShowSuccessRate = 1;
@@ -444,7 +471,7 @@ namespace Amanotes.Core.Internal
         // APIs
         internal protected abstract AdLogic interstitial { get; }
         internal protected abstract AdLogic rewardVideo { get; }
-
+        
         public abstract void ShowBanner();
         public abstract void HideBanner();
 

package/Runtime/AmaGDK.Analytics.cs

@@ -343,8 +343,7 @@ namespace Amanotes.Core
                 // All adapters should be ready now!
                 
                 // TODO: Refactor Resolve Early Calls
-                onFrameUpdate -= ProcessEventQueue;
-                onFrameUpdate += ProcessEventQueue;
+                GDKUtils.OnFrameUpdate(ProcessEventQueue);
             }
             
             internal static EventParams PrepareEvent(string eventName)

package/Runtime/AmaGDK.Mono.cs

@@ -0,0 +1,111 @@
+using Amanotes.Core.Internal;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        internal static int mainThreadId = -1;
+        internal static readonly GDKUnityCallback unityCallbacks = new GDKUnityCallback();
+        
+        internal static float realtimeSinceStartup;
+        internal static float time;
+        
+        private void Update()
+        {
+            if (!isReady) return;
+            
+            time = Time.time;
+            realtimeSinceStartup = Time.realtimeSinceStartup;
+
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnFrameUpdate);
+            cb.Invoke(ref cb.DoOnceNextFrame);
+        }
+        
+        private void OnApplicationPause(bool pauseStatus)
+        {
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnApplicationPause, pauseStatus);
+        }
+        
+        private void OnApplicationFocus(bool hasFocus)
+        {
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnApplicationFocus, hasFocus);
+        }
+        
+        private void OnApplicationQuit()
+        {
+            var cb = unityCallbacks;
+            cb.Invoke(ref cb.OnApplicationQuit);
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    
+    
+    public static partial class GDKUtils
+    {
+        public static bool isOnMainThread => Thread.CurrentThread.ManagedThreadId == AmaGDK.mainThreadId;
+        public static void DoOnMainThread(Action action)
+        {
+            if (isOnMainThread)
+            {
+                SafeInvoke(action);
+                return;
+            }
+
+            DoOnceNextFrame(action);
+        }
+        
+        public static void OnFrameUpdate(Action action)
+        {
+            var cb = AmaGDK.unityCallbacks;
+            cb.AddCallback(ref cb.OnFrameUpdate, action);
+        }
+        
+        public static void DoOnceNextFrame(Action action)
+        {
+            var cb = AmaGDK.unityCallbacks;
+            cb.AddCallback(ref cb.DoOnceNextFrame, action);
+        }
+        
+        public static void DelayCall(float seconds, Action action)
+        {
+            DoOnMainThread(() => AmaGDK._instance.StartCoroutine(DelayCallRoutine(seconds, action)));
+        }
+        
+        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;
+            }
+        }
+        
+        private static IEnumerator DelayCallRoutine(float seconds, Action callback)
+        {
+            yield return new WaitForSecondsRealtime(seconds);
+            callback();
+        }
+        
+        public static void AddUnityCallbacks<T>(T observer)
+        {
+            AmaGDK.unityCallbacks.AddObserver(observer);
+        }
+        
+        public static void RemoveUnityCallbacks<T>(T observer)
+        {
+            AmaGDK.unityCallbacks.RemoveObserver(observer);
+        }
+    }
+}

package/Runtime/AmaGDK.Mono.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 66a09cd9d2b8423e885352a8441c6468
+timeCreated: 1718074317

package/Runtime/AmaGDK.Singleton.cs

@@ -0,0 +1,27 @@
+
+using System.Threading;
+using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.Internal.Messsage;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        internal static AmaGDK _instance;
+        
+        private void Awake()
+        {
+            if (_instance != null)
+            {
+                LogWarning(MULTIPLE_INSTANCE);
+                Destroy(this);
+                return;
+            }
+            
+            _instance = this;
+            mainThreadId = Thread.CurrentThread.ManagedThreadId;
+            DontDestroyOnLoad(this);
+            StartCoroutine(InitRoutine());
+        }
+    }
+}

package/Runtime/AmaGDK.Singleton.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 059e9f9cfffd44639fc660df9537fa37
+timeCreated: 1718081104

package/Runtime/AmaGDK.UserProfile.cs

@@ -326,8 +326,7 @@ namespace Amanotes.Core
                 // Always get the latest advertising id
                 GetAdvertisingId();
                 Logging.Log($"[UserProfile] user_id: {_userId}");
-                onFrameUpdate -= SaveIfDirty;
-                onFrameUpdate += SaveIfDirty;
+                GDKUtils.OnFrameUpdate(SaveIfDirty);
                 
                 var adsId = Application.platform == RuntimePlatform.Android ? GAId : IDFA;
                 var delay = string.IsNullOrEmpty(AppsFlyerId)

package/Runtime/AmaGDK.cs

@@ -17,17 +17,16 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.64";
-
-        internal static AmaGDK _instance;
-        internal static bool _allowInit = false;
+        public const string VERSION = "0.2.66";
+        
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
         internal static readonly GDKGeoLocation GeoLocation = new GDKGeoLocation();
         internal static readonly GDKServerTime ServerTime = new GDKServerTime();
         
-        
+        internal static bool _allowInit = false;
         public bool autoInit = true;
+        
         internal static partial class Event
         {
             public const string GDK_HOOK_START = nameof(GDK_HOOK_START);
@@ -48,26 +47,6 @@ namespace Amanotes.Core
                 return _config;
             }
         }
-
-        private void Awake()
-        {
-            if (_instance != null)
-            {
-                if (_instance != this)
-                {
-                    LogWarning(MULTIPLE_INSTANCE);
-                    Destroy(this);    
-                }
-                LogWarning("Should never be here!");
-                return;
-            }
-            
-            _instance = this;
-            DontDestroyOnLoad(this);
-            
-            _allowInit = _allowInit || autoInit;
-            StartCoroutine(InitRoutine());
-        }
         
         IEnumerator InitHook()
         {
@@ -174,6 +153,8 @@ namespace Amanotes.Core
         
         IEnumerator InitRoutine()
         {
+            _allowInit = _allowInit || autoInit;
+            
             if (Config == null)
             {
                 throw new Exception("[AmaGDK] " + CONFIG_NOT_FOUND);
@@ -357,35 +338,6 @@ namespace Amanotes.Core
             public const string REVENUECAT = "RevenueCat";
         }
     }
-
-    public partial class AmaGDK
-    {
-        internal static event Action onFrameUpdate;
-        internal static event Action<bool> onApplicationPause;
-        internal static event Action<bool> applicationFocus;
-        internal static event Action applicationQuit;
-        
-        private void OnApplicationPause(bool pauseStatus)
-        {
-            onApplicationPause?.Invoke(pauseStatus);
-        }
-
-        private void OnApplicationFocus(bool hasFocus)
-        {
-            applicationFocus?.Invoke(hasFocus);
-        }
-        
-        private void Update()
-        {
-            if (!isReady) return;
-            onFrameUpdate?.Invoke();
-        }
-        
-        private void OnApplicationQuit()
-        {
-            applicationQuit?.Invoke();
-        }
-    }
     
     public partial class  AmaGDK // Switch dev mode
     {
@@ -499,7 +451,7 @@ namespace Amanotes.Core
             {
                 if (completed)
                 {
-                    LogWarning("Register happen too late: Hook completed!");
+                    LogWarning("Add happen too late: Hook completed!");
                     return;
                 }
                 

package/Runtime/Core/GDKRoutine.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections;
+using UnityEngine;
+namespace Amanotes.Core.Internal
+{
+    [Flags]
+    internal enum RoutineStatus
+    {
+        None,
+        Started = 1,
+        Stopped = 2
+    }
+    
+    public class GDKRoutine
+    {
+        private RoutineStatus status;
+        private readonly IEnumerator action;
+        private Coroutine routine;
+
+        public bool isAlive => (status & RoutineStatus.Stopped) == 0;
+        
+        public GDKRoutine(IEnumerator action)
+        {
+            this.action = action;
+            status = RoutineStatus.None;
+        }
+
+        public void StartRoutine()
+        {
+            if (!isAlive)
+            {
+                // StopRoutine() called before start: do nothing
+                return;
+            }
+            
+            status |= RoutineStatus.Started;
+            routine = AmaGDK._instance.StartCoroutine(action);
+        }
+
+        public void StopRoutine()
+        {
+            status |= RoutineStatus.Stopped;
+            if (routine != null) AmaGDK._instance.StopCoroutine(routine);
+        }
+    }
+
+    public static partial class GDKUtils
+    {
+        public static GDKRoutine StartCoroutine(IEnumerator action)
+        {
+            var routine = new GDKRoutine(action);
+            DoOnMainThread(routine.StartRoutine);
+            return routine;
+        }
+
+        public static void StopCoroutine(GDKRoutine gdkRoutine)
+        {
+            gdkRoutine.StopRoutine();
+        }
+    }
+}

package/Runtime/Core/GDKRoutine.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1a341fd3b1ed4dff93eaccd1b4d442a3
+timeCreated: 1718160748

package/Runtime/Core/GDKUnityCallback.cs

@@ -0,0 +1,141 @@
+using System;
+
+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(); }
+}
+
+namespace Amanotes.Core.Internal
+{
+    public class GDKUnityCallback
+    {
+        public Action<bool> OnApplicationPause;
+        public Action<bool> OnApplicationFocus;
+        public Action OnApplicationQuit;
+        public Action OnFrameUpdate;
+        public Action DoOnceNextFrame;
+
+        // Lock object to ensure thread-safe operations
+        private readonly object _locker = new object();
+
+        // Add Listener
+        public void AddCallback(ref Action source, Action callback)
+        {
+            if (callback == null) return;
+            lock (_locker)
+            {
+                source -= callback;
+                source += callback;
+            }
+        }
+        public void AddCallback<T>(ref Action<T> source, Action<T> callback)
+        {
+            if (callback == null) return;
+            lock (_locker)
+            {
+                source -= callback;
+                source += callback;
+            }
+        }
+
+
+        // Remove Listener
+        public void RemoveCallback(ref Action source, Action callback)
+        {
+            if (callback == null) return;
+            lock (_locker)
+            {
+                source -= callback;
+            }
+        }
+        public void RemoveCallback<T>(ref Action<T> source, Action<T> callback)
+        {
+            if (callback == null) return;
+            lock (_locker)
+            {
+                source -= callback;
+            }
+        }
+
+
+        // Invoke
+        public void Invoke(ref Action source)
+        {
+            if (source == null) return;
+            Action actionsToInvoke;
+            lock (_locker)
+            {
+                bool remove = source == DoOnceNextFrame;
+                actionsToInvoke = source;
+                if (remove) source = null;
+            }
+
+            GDKUtils.SafeInvoke(actionsToInvoke);
+        }
+        public void Invoke<T>(ref Action<T> source, T data)
+        {
+            if (source == null) return;
+            Action<T> actionsToInvoke;
+            lock (_locker)
+            {
+                actionsToInvoke = source;
+            }
+
+            GDKUtils.SafeInvoke(actionsToInvoke, data);
+        }
+        
+        
+        // Observer
+        public void AddObserver<T>(T observer)
+        {
+            if (observer == null) return;
+
+            if (observer is IOnFrameUpdate u)
+            {
+                AddCallback(ref OnFrameUpdate, u.OnFrameUpdate);
+            }
+
+            if (observer is IOnApplicationPause p)
+            {
+                AddCallback(ref OnApplicationPause, p.OnApplicationPause);
+            }
+
+            if (observer is IOnApplicationFocus f)
+            {
+                AddCallback(ref OnApplicationFocus, f.OnApplicationFocus);
+            }
+
+            if (observer is IOnApplicationQuit q)
+            {
+                AddCallback(ref OnApplicationQuit, q.OnApplicationQuit);
+            }
+        }
+        public void RemoveObserver<T>(T observer)
+        {
+            if (observer == null) return;
+
+            if (observer is IOnFrameUpdate u)
+            {
+                RemoveCallback(ref OnFrameUpdate, u.OnFrameUpdate);
+            }
+
+            if (observer is IOnApplicationPause p)
+            {
+                RemoveCallback(ref OnApplicationPause, p.OnApplicationPause);
+            }
+
+            if (observer is IOnApplicationFocus f)
+            {
+                RemoveCallback(ref OnApplicationFocus, f.OnApplicationFocus);
+            }
+
+            if (observer is IOnApplicationQuit q)
+            {
+                RemoveCallback(ref OnApplicationQuit, q.OnApplicationQuit);
+            }
+        }
+    }
+}

package/Runtime/Core/GDKUnityCallback.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 597f549a7af24670b911da2047054e5e
+timeCreated: 1718085791

package/Runtime/Core.meta

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

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,65 +12,8 @@ using static Amanotes.Core.Internal.Logging;
 
 namespace Amanotes.Core.Internal
 {
-    public static class GDKUtils
+    public static partial class GDKUtils
     {
-        public static void StartCoroutine(IEnumerator action)
-        {
-            AmaGDK._instance.StartCoroutine(action);
-        }
-        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)
@@ -157,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)

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.64",
+    "version": "0.2.65-1",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",