com.amanotes.gdk 0.2.64 → 0.2.65-2

package/Runtime/Internal/ForceQuitMonitor.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Amanotes.Core.Internal
+{
+    public class ForceQuitMonitor : IOnApplicationFocus, IOnApplicationPause
+    {
+        [Serializable]
+        internal class AdsEvent
+        {
+            [NonSerialized]
+            internal const string EVENT_NAME = "force_quit";
+            [SerializeField]
+            internal string reason;
+            [SerializeField]
+            internal string detail;
+            
+            internal Dictionary<string, object> Parameters => new Dictionary<string, object>
+            {
+                {"reason", reason},
+                {"detail", detail}
+            };
+        }
+    
+        [Serializable]
+        private class ForceQuitData : IJsonFile
+        {
+            [SerializeField]
+            internal AdsEvent adsEvent;
+            [NonSerialized]
+            internal bool isDirty;
+            
+            internal void SaveIfDirty(bool forceSave = false)
+            {
+                if (!isDirty && !forceSave) return;
+                this.SaveJsonToFile();
+                isDirty = false;
+            }
+        }
+                
+        private readonly ForceQuitData localData = new ForceQuitData();
+
+        private string GetStringValueOrDefault(Dictionary<string, object> dict, string key, string defaultValue = "")
+        {
+            return dict.TryGetValue(key, out object result) 
+                ? result.ToString().Trim().ToLower()
+                : defaultValue;
+        }
+        
+        public void OnLogEvent(string eventNameToSend, Dictionary<string, object> parameters)
+        {
+            switch (eventNameToSend)
+            {
+                case "videoads_show_called":
+                    localData.adsEvent = new AdsEvent { reason = "watch_videoads" };
+                    localData.isDirty = true;
+                    break;
+                case "fullads_show_called":
+                    localData.adsEvent = new AdsEvent { reason = "watch_fullads" };
+                    localData.isDirty = true;
+                    break;
+                case "ad_impression":
+                    string adFormat = GetStringValueOrDefault(parameters, "ad_format");
+                    if (adFormat == "rewarded_video" || adFormat == "interstitial") break;
+                    
+                    if (localData.adsEvent != null)
+                    {
+                        var detailParams = new Dictionary<string, object>
+                        {
+                            ["ad_source"] = GetStringValueOrDefault(parameters, "ad_source"),
+                            ["ad_unit_name"] = GetStringValueOrDefault(parameters, "ad_unit_name") 
+                        };
+                        localData.adsEvent.detail = JsonUtils.DictionaryToJson(detailParams);
+                        localData.SaveIfDirty(true);
+                    }
+                    break;
+                case "videoads_show_notready":
+                case "videoads_finish":
+                case "fullads_show_notready": 
+                case "fullads_finish":
+                    localData.adsEvent = null;
+                    localData.isDirty = true;
+                    break;
+            }
+        }
+
+        public void Init()
+        {
+            GDKUtils.AddUnityCallbacks(this);
+            OnAppOpen();
+        }
+
+        public void OnAppOpen()
+        {
+            localData.LoadJsonFromFile();
+            if (localData.adsEvent == null || string.IsNullOrWhiteSpace(localData.adsEvent.reason)) return;
+            AmaGDK.Analytics.LogEvent(AdsEvent.EVENT_NAME, localData.adsEvent.Parameters);
+            localData.adsEvent = null;
+        }
+        
+        public void OnApplicationFocus(bool hasFocus)
+        {
+            if (!hasFocus) localData.SaveIfDirty();
+        }
+        public void OnApplicationPause(bool pauseStatus)
+        {
+            if (pauseStatus) localData.SaveIfDirty();
+        }
+    }
+}

package/Runtime/Internal/ForceQuitMonitor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9c9f11bdd3e34b8ea54c88e412132dc6
+timeCreated: 1717642885

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-2",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",