com.amanotes.gdk 0.2.47 → 0.2.48

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.2.48 - 2024-01-15]
+- Add GDKTest project for Unity versions 2020.3, 2021.3 and 2022.3
+- Integrate Klavar library & toolset
+
 ## [0.2.47 - 2024-01-09]
 - Some clean up, null checks & improvements for AmaGDK Editor
 - Add GDKTest project for Unity versions 2020.3, 2021.3 and 2022.3
@@ -261,4 +265,4 @@ Update Ads module:
 ## [0.1.2] - 2023-02-08
 - Release AmaGDK 0.1.2
 - FirebaseAnalytics adapter compatible with FirebaseAnalytics SDK v9
-- AppsFlyer adapter compatible with AppsFlyer SDK v6
+- AppsFlyer adapter compatible with AppsFlyer SDK v6

package/Runtime/AmaGDK.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.47";
+        public const string VERSION = "0.2.48";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;

package/Runtime/Klavar/Attributes/AccumulatedCountAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Accumulated Count Attribute
+    /// </summary>
+    ///
+    public class AccumulatedCountAttribute : ConverterLogEventAttribute
+    {   
+        public override object Convert(object parent, FieldInfo fieldInfo, object param)
+        {
+            var classType = parent.GetType();
+            var attr = (EventNameAttribute) GetCustomAttribute(classType, typeof(EventNameAttribute));
+            return AmaGDK.Analytics.GetAccumulatedCount(attr.name) + 1;
+        }
+    }
+}

package/Runtime/Klavar/Attributes/AccumulatedCountAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4676ec6aa5eac4473b464688797b7e74
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/ConnectionAttribute.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Get Connection Attribute
+    /// </summary>
+    public class ConnectionAttribute : ConverterLogEventAttribute
+    {
+        public override object Convert(object parent, FieldInfo fieldInfo, object param)
+        {
+            return Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork ?
+                    "online" : "offline";
+        }
+    }
+}

package/Runtime/Klavar/Attributes/ConnectionAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4a5ccb72b88f14dfd830e677754f07df
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/CountInSessionAttribute.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Get Connection Attribute
+    /// </summary>
+    public class CountInSessionAttribute : ConverterLogEventAttribute
+    {
+        static readonly Dictionary<string, int> countInSessions = new Dictionary<string, int>();
+
+        public override object Convert(object parent, FieldInfo fieldInfo, object param)
+        {
+            // return AmaGDK.Ads.InterstitialShowCalledInSession;
+            string name = parent.GetType().FullName;
+            if (!countInSessions.TryGetValue(name, out var count))
+            {
+                count = countInSessions[name] = 1;
+                return 1;
+            }
+            count = countInSessions[name] = count + 1;
+            return count;
+        }
+    }
+}

package/Runtime/Klavar/Attributes/CountInSessionAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c775bcc69b77340e7a160f75ce5a249f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/DescriptionAttribute.cs

@@ -0,0 +1,7 @@
+namespace Amanotes.Core
+{
+    public class DescriptionAttribute : KlavarEventAttribute
+    {
+        public DescriptionAttribute(string description) { }
+    }
+}

package/Runtime/Klavar/Attributes/DescriptionAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3ab249f3648b84b6db12944cea37b8d0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/DynamicValidateAttribute.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Dynamic validate param by Function 
+    /// </summary>
+    public class DynamicValidateAttribute : ValidateLogEventAttribute
+    {
+        readonly string functioName;
+        public DynamicValidateAttribute(string functionName)
+        {
+            this.functioName = functionName;
+        }
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            var function = param.GetType().GetMethod(functioName);
+            try
+            {
+                function?.Invoke(parent, new object[] { param });
+            }
+            catch (Exception e)
+            {
+                throw new ArgumentException($"Field {fieldInfo.Name} is in-valid with error {e.Message}");
+            }
+        }
+    }
+}

package/Runtime/Klavar/Attributes/DynamicValidateAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40accc99a6f324666902522f4305acd3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/IgnoreAttribute.cs

@@ -0,0 +1,16 @@
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Ignore this param
+    /// </summary>
+    public class IgnoreAttribute : KlavarEventAttribute
+    {
+    }
+}
+
+
+
+
+
+
+

package/Runtime/Klavar/Attributes/IgnoreAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4959d05652b9c461c8d8c3ddba63d934
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/MinMaxAttribute.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Min, Max validate param
+    /// </summary>
+    public class MinMaxAttribute : ValidateLogEventAttribute
+    {
+
+        public readonly double min;
+
+        public readonly double max;
+
+        public MinMaxAttribute(double min, double max)
+        {
+            this.min = min;
+            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 < 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
+    {
+
+        public readonly double min;
+
+
+        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}");
+        }
+    }
+
+
+    public class ExclusiveMinimumAttribute : ValidateLogEventAttribute
+    {
+
+        public readonly double min;
+
+
+        public ExclusiveMinimumAttribute(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 {min}. Current value: {param}");
+        }
+    }
+
+
+
+
+
+    public class MaximumAttribute : ValidateLogEventAttribute
+    {
+
+        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)
+        {
+            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 to {max}. Current value: {param}");
+        }
+    }
+}
+
+

package/Runtime/Klavar/Attributes/MinMaxAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c773f7760fee54649bbd4adc39fc2c5b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/MinMaxLengthAttribute.cs

@@ -0,0 +1,88 @@
+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;
+
+        public MinMaxLengthAttribute(int min, int max)
+        {
+            this.min = min;
+            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}");
+        }
+    }
+
+
+    public class MinLengthAttribute : ValidateLogEventAttribute
+    {
+        public 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}");
+        }
+    }
+
+
+    public class MaxLengthAttribute : ValidateLogEventAttribute
+    {
+        public 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}");
+        }
+    }
+
+
+    public class FixedLengthAttribute : ValidateLogEventAttribute
+    {
+        public readonly int length;
+
+        public FixedLengthAttribute(int length)
+        {
+            this.length = length;
+        }
+
+        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}");
+        }
+    }
+}
+
+

package/Runtime/Klavar/Attributes/MinMaxLengthAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b927e38cacb34a7195b04f17f90c2f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/NameAttribute.cs

@@ -0,0 +1,35 @@
+
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+
+    /// <summary>
+    /// Change the Name of param
+    /// </summary>
+    public class NameAttribute : NamingLogEventAttribute
+    {
+        public readonly string name;
+
+        public NameAttribute(string name)
+        {
+            this.name = name;
+        }
+        public override string GetName(object parent, FieldInfo fieldInfo) => name;
+    }
+
+
+
+    /// <summary>
+    /// Set the event name
+    /// </summary>
+    public class EventNameAttribute : KlavarEventAttribute
+    {
+        public readonly string name;
+
+        public EventNameAttribute(string name)
+        {
+            this.name = name;
+        }
+    }
+}

package/Runtime/Klavar/Attributes/NameAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 47031184d3e984c99abbca06a5c51fe0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/NotNullAttribute.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Not null validate param
+    /// </summary>
+    public class NotNullAttribute : ValidateLogEventAttribute
+    {
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (param is null) throw new ArgumentException($"Field `{fieldInfo.Name}` must not be null");
+        }
+    }
+}

package/Runtime/Klavar/Attributes/NotNullAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a9edce640cd3545c6a026d6590a1f50d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/RegexPatternAttribute.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace Amanotes.Core
+{
+#pragma warning disable CS3015
+
+    /// <summary>
+    /// Apply Regex Validation for param
+    /// </summary>
+    public class RegexPatternAttribute : ValidateLogEventAttribute
+    {
+        public readonly string[] regexes;
+
+
+        public RegexPatternAttribute(string regex)
+        {
+            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)
+            {
+                var match = Regex.Match(param.ToString(), regex);
+                if (match != null && match.Success) return;
+            }
+            throw new ArgumentException($"Field `{fieldInfo.Name}` is not match as {this.GetType().Name.Replace("Attribute", "")}");
+        }
+    }
+
+#pragma warning restore CA2200
+
+    /// <summary>
+    /// Is Email validate Param
+    /// </summary>
+    public class IsEmailAddressAttribute : RegexPatternAttribute
+    {
+        public IsEmailAddressAttribute() : base(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$") { }
+    }
+
+    /// <summary>
+    /// Is ObjectID validate param
+    /// </summary>
+    public class IsObjectIDAttribute : RegexPatternAttribute
+    {
+        public IsObjectIDAttribute() : base(@"^(?=[a-f\d]{24}$)(\d+[a-f]|[a-f]+\d)") { }
+    }
+}

package/Runtime/Klavar/Attributes/RegexPatternAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b25602076710f4965a41f41a5d1afb46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/TimeDiffLastFireAttribute.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public class TimeDiffLastFireAttribute : ConverterLogEventAttribute
+    {
+        static readonly Dictionary<string, float> lastFireInSessions = new Dictionary<string, float>();
+
+        public override object Convert(object parent, FieldInfo fieldInfo, object param)
+        {
+            // return AmaGDK.Ads.InterstitialShowCalledInSession;
+            string name = parent.GetType().FullName;
+            if (!lastFireInSessions.TryGetValue(name, out var lastFire))
+            {
+                lastFireInSessions[name] = Time.realtimeSinceStartup;
+                return 0;
+            }
+
+            var current = Time.realtimeSinceStartup;
+            var diff = Mathf.RoundToInt(current - lastFire);
+            lastFireInSessions[name] = current;
+            return diff;
+        }
+    }
+
+}

package/Runtime/Klavar/Attributes/TimeDiffLastFireAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e93b0c22875584b17840d4a5c8e30424
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/ToStringAttribute.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+#pragma warning disable CS3005
+
+    /// <summary>
+    /// Convert param to string 
+    /// </summary>
+    public class ToStringAttribute : ConverterLogEventAttribute
+    {
+        public enum Converter
+        {
+            NoThing,
+
+            ToLowerCase,
+            ToUpperCase,
+
+            ToSnakeCase,
+            ToCamelCase,
+            ToPascalCase,
+            ToKebabCase
+        }
+
+        static readonly Dictionary<Converter, Func<string, string>> convertMethods = new Dictionary<Converter, Func<string, string>>()
+    {
+        {Converter.NoThing, val=>val},
+        {Converter.ToLowerCase, KlavarEventUtils.ToLowerCase},
+        {Converter.ToUpperCase, KlavarEventUtils.ToUpperCase},
+        {Converter.ToSnakeCase, KlavarEventUtils.ToSnakeCase},
+        {Converter.ToCamelCase, KlavarEventUtils.ToCamelCase},
+        {Converter.ToPascalCase, KlavarEventUtils.ToPascalCase},
+        {Converter.ToKebabCase, KlavarEventUtils.ToKebabCase},
+    };
+
+        public readonly Converter converter;
+
+        public ToStringAttribute() { converter = Converter.NoThing; }
+
+        public ToStringAttribute(Converter converter)
+        {
+            this.converter = converter;
+        }
+
+        private string GetValueAsString(object enumVal)
+        {
+            // get the field 
+            var field = enumVal.GetType().GetField(enumVal.ToString());
+            var attr = field.GetCustomAttribute<ValueAttribute>();
+
+            return attr != null ? convertMethods[converter](attr.sValue) : convertMethods[converter](enumVal.ToString());
+        }
+
+        public override object Convert(object parent, FieldInfo fieldInfo, object param)
+        {
+            return GetValueAsString(param);
+        }
+    }
+
+
+    public class ToStringLowerCase : ToStringAttribute
+    {
+        public ToStringLowerCase() : base(ToStringAttribute.Converter.ToLowerCase) { }
+    }
+
+
+    public class ToStringUpperCase : ToStringAttribute
+    {
+        public ToStringUpperCase() : base(ToStringAttribute.Converter.ToUpperCase) { }
+    }
+
+
+    public class ToStringToSnakeCase : ToStringAttribute
+    {
+        public ToStringToSnakeCase() : base(ToStringAttribute.Converter.ToSnakeCase) { }
+    }
+
+    public class ToStringCamelCase : ToStringAttribute
+    {
+        public ToStringCamelCase() : base(ToStringAttribute.Converter.ToCamelCase) { }
+    }
+
+    public class ToStringPascalCase : ToStringAttribute
+    {
+        public ToStringPascalCase() : base(ToStringAttribute.Converter.ToPascalCase) { }
+    }
+
+
+    public class ToStringKebabCase : ToStringAttribute
+    {
+        public ToStringKebabCase() : base(ToStringAttribute.Converter.ToKebabCase) { }
+    }
+
+#pragma warning restore CS3005
+}

package/Runtime/Klavar/Attributes/ToStringAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 68cd1a5ce6bfe432d8fceab8620a0d0f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/ValueAttribute.cs

@@ -0,0 +1,30 @@
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Change the value of param to new value in the attribute
+    /// </summary>
+    public class ValueAttribute : KlavarEventAttribute
+    {
+        public readonly int iValue;
+        public readonly string sValue;
+        public readonly float fValue;
+        public readonly double dValue;
+        public ValueAttribute(int value)
+        {
+            this.iValue = value;
+        }
+        public ValueAttribute(string value)
+        {
+            this.sValue = value;
+        }
+        public ValueAttribute(float value)
+        {
+            this.fValue = value;
+        }
+
+        public ValueAttribute(double value)
+        {
+            this.dValue = value;
+        }
+    }
+}

package/Runtime/Klavar/Attributes/ValueAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a4ddd16b5626545308d6e9948917f0a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes.meta

@@ -0,0 +1,12 @@
+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: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/KlavarEvent.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// LogEvent parameters Schema
+    /// </summary>
+    public abstract class KlavarEvent
+    {
+        /// <summary>
+        /// LogEvent
+        /// </summary>
+        /// <exception cref="ArgumentException"></exception>
+        public void LogEvent()
+        {
+            var type = this.GetType();
+            var eventNameAttr = (EventNameAttribute)Attribute.GetCustomAttribute(type, typeof(EventNameAttribute));
+
+            if (eventNameAttr == null)
+                throw new ArgumentException($"Add `EventName` attribute to class {type.FullName}");
+            
+            var @params = this.ToDict();
+            var eventName = eventNameAttr.name;
+            AmaGDK.Analytics.LogEvent(eventName, @params);
+        }
+
+
+        /// <summary>
+        /// throw exception from attribute if field is invalid.
+        /// </summary>
+        /// <param name="field"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentException">when field go wrong.</exception>
+        private FieldInfo Validate(FieldInfo field)
+        {
+            var param = field.GetValue(this);
+            var attrs = field.GetCustomAttributes<ValidateLogEventAttribute>(true);
+            foreach (var attr in attrs) attr.Validate(this, field, param);
+
+            return field;
+        }
+
+        /// <summary>
+        /// Apply converter attribute in field.
+        /// </summary>
+        /// <param name="field"></param>
+        /// <returns></returns>
+        private object Convert(FieldInfo field)
+        {
+            var attrs = field.GetCustomAttributes<ConverterLogEventAttribute>(true);
+            var param = field.GetValue(this);
+            foreach (var attr in attrs) param = attr.Convert(this, field, param);
+            return param;
+        }
+
+
+        /// <summary>
+        /// Convert the name in field to new name by attribute.
+        /// </summary>
+        /// <param name="field"></param>
+        /// <returns>the new param name</returns>
+        private string GetName(FieldInfo field)
+        {
+            var attr = field.GetCustomAttribute<NamingLogEventAttribute>(true);
+            var param = field.GetValue(this);
+            return attr?.GetName(this, field) ?? field.Name;
+        }
+
+
+        /// <summary>
+        /// Convert all params to dict by field name.
+        /// </summary>
+        /// <returns>dictionary of params</returns>
+        public Dictionary<string, object> ToDict()
+        {
+            return this
+                .GetType()
+                .GetFields()
+                .Where(field => field.GetCustomAttribute<IgnoreAttribute>() == null)
+                .Select(field => Validate(field))
+                .ToDictionary(
+                    field => GetName(field),
+                    field => Convert(field)
+                );
+        }
+    }
+}

package/Runtime/Klavar/KlavarEvent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3d37423ab39204191b9b7c3d3ea832b2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/KlavarEventAttribute.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Reflection;
+
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Pretty Log Event Attribute
+    /// </summary>
+    public abstract class KlavarEventAttribute : Attribute
+    {
+    }
+
+    /// <summary>
+    /// Validate Property Attribute
+    /// </summary>
+    public abstract class ValidateLogEventAttribute : KlavarEventAttribute
+    {
+        public abstract void Validate(object parent, FieldInfo fieldInfo, object param);
+    }
+
+    /// <summary>
+    /// Converter Value of Property Attribute
+    /// </summary>
+    public abstract class ConverterLogEventAttribute : KlavarEventAttribute
+    {
+        public abstract object Convert(object parent, FieldInfo fieldInfo, object param);
+    }
+
+
+    /// <summary>
+    /// Nameing Property Attribute
+    /// </summary>
+    public abstract class NamingLogEventAttribute : KlavarEventAttribute
+    {
+        public abstract string GetName(object parent, FieldInfo fieldInfo);
+    }
+}
+

package/Runtime/Klavar/KlavarEventAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2c3072fee96b44e089d862bfd938f252
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/KlavarEventTools.cs

@@ -0,0 +1,92 @@
+//
+// #if UNITY_EDITOR
+//
+// using System.Linq;
+// using System.Collections;
+// using UnityEditor;
+// using UnityEngine;
+//
+// using System.IO;
+// using System.Collections.Generic;
+// using System;
+//
+// namespace Amanotes.Core
+// {
+//     /// <summary>
+//     /// Prety Log Event Tools
+//     /// </summary>
+//     public class KlavarEventTools
+//     {
+//         public class KlavarEventLine
+//         {
+//             public string No;
+//             public string EventName;
+//             public string EventParameterName;
+//
+//             public string ValueType;
+//
+//             public string ParameterValue;
+//
+//             public bool IsInvalid()
+//             {
+//                 return string.IsNullOrWhiteSpace(No)
+//                     && string.IsNullOrWhiteSpace(EventName)
+//                     && string.IsNullOrWhiteSpace(EventParameterName)
+//                     && string.IsNullOrWhiteSpace(ValueType)
+//                     && string.IsNullOrWhiteSpace(ParameterValue);
+//             }
+//         }
+//
+//         static private IEnumerable<T[]> Chunk<T>(IEnumerable<T> colection, Func<T, bool> splitter)
+//         {
+//
+//             IEnumerator<T> iter = colection.GetEnumerator();
+//             var running = iter.MoveNext();
+//
+//             IEnumerable<T> OneChunk()
+//             {
+//                 yield return iter.Current;
+//                 while (running = iter.MoveNext())
+//                 {
+//                     var val = iter.Current;
+//                     if (splitter(val)) break;
+//                     yield return val;
+//                 }
+//             }
+//
+//             while (running)
+//             {
+//                 var chunk = OneChunk().ToArray();
+//                 if (chunk.Length > 0) yield return chunk;
+//             }
+//         }
+//
+//
+//         static void ConvertFromCSV()
+//         {
+//
+//             // string path = EditorUtility.OpenFilePanel("Overwrite with png", ".", "tsv");
+//
+//             var path = "/Users/nam.dn/Downloads/Test Pretty Event - Ad Mon.tsv";
+//             if (string.IsNullOrEmpty(path)) return;
+//
+//
+//             Debug.Log(path);
+//             string text = File.ReadAllText(path);
+//             var lines = Amanotes.Klavar.TSVParser
+//                 .Parse<KlavarEventLine>(text)
+//                 .Where(line => !line.IsInvalid());
+//
+//             var linesEvents = Chunk(lines, line => !string.IsNullOrEmpty(line.No));
+//             foreach (var linesEvent in linesEvents)
+//             {
+//                 Debug.Log(linesEvent[0]);
+//                 Debug.Log(linesEvent.Length);
+//
+//                 var linesParams = Chunk(lines, line => !string.IsNullOrEmpty(line.EventParameterName));
+//
+//             }
+//         }
+//     }
+// }
+// #endif

package/Runtime/Klavar/KlavarEventTools.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4dc125edcd6594383a73b65b72442585
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/KlavarEventUtils.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Convert string to some famous case
+    /// https://dev.to/ankitmalikg/difference-among-casings-snake-case-vs-camel-case-vs-pascal-case-vs-kebab-case-2m8b#:~:text=Pascal%20Case%20is%20similar%20to,C%23%2C%20Java%2C%20and%20TypeScript.
+    /// </summary>
+    internal class KlavarEventUtils
+    {
+        private static readonly char[] delimiters = { '-', '_', ' ' };
+        // private static readonly string delimiters =  "_- ";
+        public static string[] ToTokens(string text)
+        {
+            text = Regex.Replace(text, "([A-Z])", " $1");
+            var tokens = text.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);
+            return tokens;
+        }
+
+
+        public static string ToLowerCase(string text) => text.ToLower();
+
+        public static string ToUpperCase(string text) => text.ToUpper();
+
+        /// <summary>
+        /// Convert string to SnakeCase
+        /// </summary>
+        /// <param name="text"></param>
+        /// <returns></returns>
+        public static string ToSnakeCase(string text)
+        {
+            var tokens = ToTokens(text);
+            return string.Join("_", tokens.Select(t => t.ToLower()));
+        }
+
+        public static string ToCamelCase(string text)
+        {
+            var tokens = ToTokens(text);
+            return string.Join("", tokens.Select(t => Char.ToUpper(t[0]) + t.Substring(1).ToLower()));
+        }
+
+        public static string ToPascalCase(string text)
+        {
+            var tokens = ToTokens(text);
+            return string.Join("", tokens.Select((t, i) =>
+                (i == 0 ? Char.ToLower(t[0]) : Char.ToUpper(t[0])) + t.Substring(1).ToLower()));
+        }
+
+        public static string ToKebabCase(string text)
+        {
+            var tokens = ToTokens(text);
+            return string.Join("-", tokens.Select(t => t.ToLower()));
+        }
+    }
+}

package/Runtime/Klavar/KlavarEventUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f0ef1f5f6bb274056b4b47df1a473529
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar.meta

@@ -0,0 +1,12 @@
+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: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

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

package/Runtime/Core.meta

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