com.amanotes.gdk 0.2.56 → 0.2.58

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.2.58 - 2024-04-09]
+- [DEV] combine code coverage report
+- [Dev] Improve GDK Utils
+- [Dev] Add hints to AdCallback APIs
+- [Fix] timeDiffLastFire always returns 0 in adShowCalled callbacks
+- [Fix] Various warnings fixes due to invalid examples
+- [Fix] Warning on AdContext destroyed caused by invalid editor ad callback
+
+
+## [0.2.57 - 2024-04-08]
+- [Dev] Fix bug in value conversion within KlavarEvent
+- [Dev] Auto get change log
+- [Dev] Auto publish command
+- [Dev] Upgrade to Unity 2021.3.35f1
+- [Dev] Add support for various banner sizes in IronsourceAdapter
+- [Dev] Clean up and add tooltip for options
+- [Fix] Null exception in LocalBuild Version
+
+
 ## [0.2.56 - 2024-04-03]
 - Release AmaGDK v0.2.56
 

package/Editor/AmaGDKEditor.cs

@@ -369,20 +369,7 @@ namespace Amanotes.Editor
             {
                 configOpen.Add(adapterId, isOpen = false);
             }
-
-            // if (adapter == null)
-            // {
-            //     // EditorGUILayout.HelpBox("Adapter<" + adapterId + "> not imported!", MessageType.Info);
-            //     string adapterName = FindBestAdapterFor(adapterId);
-            //     var package = $"{Res.PACKAGE_PATH}{adapterName}";
-            //     
-            //     if (GUILayout.Button(adapterName))
-            //     {
-            //         AssetDatabase.ImportPackage(package, false);    
-            //     }
-            //     return;
-            // }
-
+            
             SDKStatus status = SDKStatus.Get(adapterId);
             bool changed = AmaGUI.Foldout(ObjectNames.NicifyVariableName(adapterId), ref isOpen, () =>
             {
@@ -461,18 +448,21 @@ namespace Amanotes.Editor
                 EditorGUILayout.HelpBox($"{adapterId} SDK not installed", MessageType.Warning);
                 return;
             }
+            
             if (!status.adapterInstalled)
             {
                 EditorGUILayout.HelpBox($"{adapterId}-GDKAdapter not installed", MessageType.Warning);
+                if (adapterId == IRONSOURCE)
+                {
+                    AmaGUI.Foldout("Enabled AdNetworks", ref showIRSAdapter, () =>
+                    {
+                        DrawIRSAdapterVersions();
+                        GUILayout.Space(8f);
+                    });
+                }
                 return;
-            }
-
-            if (!status.adapterInstalled)
-            {
-                EditorGUILayout.HelpBox($"{adapterId}-GDKAdapter not installed", MessageType.Warning);
-                return;
-            }
-
+            } 
+            
             DrawModuleConfig(adapter, adapterId);
         }
 

package/Editor/Extra/GDKLocalBuild.cs

@@ -11,7 +11,7 @@ using UnityObject = UnityEngine.Object;
 
 namespace Amanotes.Editor
 {
-    [CreateAssetMenu(menuName = "Ama GDK/Build Config", fileName = "LocalBuild")]
+    [CreateAssetMenu(menuName = "Ama GDK/Local Build Config", fileName = "LocalBuild")]
     public class GDKLocalBuild : ScriptableObject
     {
         private const string DEFAULT_BUILD_FOLDER = "../../_Build";
@@ -37,7 +37,6 @@ namespace Amanotes.Editor
         public List<UnityObject> listUnused;
         public BuildRequestTS buildRQ;
         public UnityEvent beforeBuild;
-        public TextAsset shTemplate;
         
         [NonSerialized] private BuildInfo _buildInfo;
         [NonSerialized] private int _lockCount;
@@ -493,12 +492,14 @@ namespace Amanotes.Editor
                 buildNumber++;
                 if (string.IsNullOrEmpty(buildVersion)) buildVersion = "1.0.0";
 
-                string[] arr = buildVersion.Split('.');
-                int last = int.Parse(arr[2]);
+                List<string> list = buildVersion.Split('.').ToList();
+                if (list.Count < 2) list.Add("0");
+                if (list.Count < 3) list.Add("0");
+                int last = int.Parse(list[2]);
                 last++;
 
-                arr[2] = last.ToString();
-                buildVersion = string.Join(".", arr);
+                list[2] = last.ToString();
+                buildVersion = string.Join(".", list);
             }
         }
 

package/Runtime/AmaGDK.Adapters.cs

@@ -13,7 +13,7 @@ namespace Amanotes.Core.Internal
         [HideInInspector] [SerializeField] internal bool enabled = true;
         [NonSerialized] internal string adapterId;
         [NonSerialized] internal string adapterVersion;
-        [NonSerialized] protected internal Status status = Status.None;
+        [NonSerialized] internal protected Status status = Status.None;
         
         protected abstract void Init(Action<bool> onComplete);
         

package/Runtime/AmaGDK.Ads.cs

@@ -9,10 +9,11 @@ using static Amanotes.Core.AmaGDK;
 
 namespace Amanotes.Core
 {
-    
-    
     public static class AdExtension
     {
+        /// <summary>
+        /// Invoke when ad view has opened
+        /// </summary>
         public static IAdCallback OnAdOpened(this IAdCallback ad, Action callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -21,6 +22,9 @@ namespace Amanotes.Core
             return ad;
         }
         
+        /// <summary>
+        /// The user finished watching the video, and should be rewarded.
+        /// </summary>
         public static IAdCallback OnRewardReceived(this IAdCallback ad, Action callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -29,6 +33,9 @@ namespace Amanotes.Core
             return ad;
         }
         
+        /// <summary>
+        /// Invoked when the video ad was clicked.
+        /// </summary>
         public static IAdCallback OnAdClicked(this IAdCallback ad, Action callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -37,6 +44,9 @@ namespace Amanotes.Core
             return ad;
         }
         
+        /// <summary>
+        /// Callback when the rewarded video ad was failed to show
+        /// </summary>
         public static IAdCallback OnAdShowFailed(this IAdCallback ad, Action callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -45,6 +55,9 @@ namespace Amanotes.Core
             return ad;
         }
         
+        /// <summary>
+        /// Invoked before OnAdOpened but is not reliable (not supported by all adNetworks)
+        /// </summary>
         public static IAdCallback OnAdShowSuccess(this IAdCallback ad, Action callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -53,6 +66,9 @@ namespace Amanotes.Core
             return ad;
         }
         
+        /// <summary>
+        /// Invoke when ad view is about to be closed
+        /// </summary>
         public static IAdCallback OnAdClosed(this IAdCallback ad, Action callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -61,6 +77,11 @@ namespace Amanotes.Core
             return ad;
         }
         
+        /// <summary>
+        /// This callback may invokes several times according to the AdShowReadyStatus
+        /// - When there is no ad cached (wifi disabled / no internet / wait4Ad / timeout)
+        /// - When the ad is cached & ready to show
+        /// </summary>
         public static IAdCallback OnAdShowReadyStatus(this IAdCallback ad, Action<AdShowReadyStatus> callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -69,6 +90,10 @@ namespace Amanotes.Core
             return ad;
         }
         
+        /// <summary>
+        /// The finalize callback that will always trigger to mark an end for the AdShowRoutine
+        /// 
+        /// </summary>
         public static IAdCallback OnAdResult(this IAdCallback ad, Action<bool> callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;
@@ -79,7 +104,7 @@ namespace Amanotes.Core
         
         /// <summary>
         /// Call right before the ad actually open (that means Ad has already been cached & available to show).
-        /// This callback will not be triggered in case Ad is not available or no internet
+        /// This callback will not be triggered in case Ad is not available or no internet (in those case use OnAdShowReadyStatus callback)
         /// </summary>
         public static IAdCallback OnBeforeAdOpen(this IAdCallback ad, Action callback)
         {
@@ -126,7 +151,8 @@ namespace Amanotes.Core
         internal class AdStat
         {
             // per session
-            internal float lastCallTime;
+            internal float prevCallTime;
+            internal float currentCallTime;
             internal int callCount;
             
             internal float lastSuccessTime;
@@ -156,7 +182,18 @@ namespace Amanotes.Core
             
             internal int TimeSinceLastShowCalled(AdType adType)
             {
-                return (int)(Time.realtimeSinceStartup - GetStat(adType).lastCallTime);
+                AdStat stat = GetStat(adType);
+                AdShowContext context = Ads.context;
+                
+                // Right inside XXX_ShowCalled() callbacks
+                if (context != null && context.adType == adType)
+                {
+                    if (stat.callCount == 1) return 0; // first call
+                    return (int)(stat.currentCallTime - stat.prevCallTime);
+                }
+                
+                if (stat.callCount == 0) return 0; // not yet called
+                return (int)(Time.realtimeSinceStartup - stat.prevCallTime);
             }
 
             internal int TimeSinceLastShowSuccess(AdType adType)
@@ -173,20 +210,7 @@ namespace Amanotes.Core
         [Serializable]
         public class AdAdapterConfig
         {
-            // public bool manualInit;
-            public int adLoadTimeoutInSecs = 60;
-            public int adShowTimeoutInSecs = 5;
-            public BannerPosition bannerPosition = BannerPosition.BOTTOM;
-            public bool autoLogEvent = true;
-
-            public bool enableInterstitial = true;
-            public bool enableRewarded = true;
-            public bool enableBanner = true;
-            public bool autoMute = true;
-            public bool autoTimeScale = true;
             
-            [Header("EDITOR")]
-            [Range(0f, 1f)] public float rewardAdShowSuccessRate = 1;
         }
 
         public partial class Ads
@@ -255,7 +279,7 @@ namespace Amanotes.Core
                 if (_isBannerShowing)
                 {
                     _isBannerShowing = false;
-                    ShowBanner(_showingBannerPosition);
+                    ShowBanner();
                 }
             }
 
@@ -298,22 +322,22 @@ namespace Amanotes.Core
 
 
             private static bool _isBannerShowing;
-            private static BannerPosition _showingBannerPosition;
             
-            public static void ShowBanner(BannerPosition? bannerPosition = null)
+            public static void ShowBanner()
             {
+                if (_config.ad.enableBanner) return;
+                
                 if (_isBannerShowing) return;
                 _isBannerShowing = true;
-                _showingBannerPosition = bannerPosition ?? Config.ad.bannerPosition;
-
                 if (_adapter == null) return;
 
                 dispatcher.Dispatch(Event.BANNER_SHOW);
-                _adapter.ShowBanner(_showingBannerPosition);
+                _adapter.ShowBanner();
             }
 
             public static void HideBanner()
             {
+                if (_config.ad.enableBanner) return;
                 if (!_isBannerShowing) return;
                 _isBannerShowing = false;
                 if (_adapter == null) return;
@@ -369,22 +393,27 @@ namespace Amanotes.Core.Internal
 {
     [Serializable] public class AdModuleConfig
     {
-        // [Header("-----     MODULE CONFIG      -----")]
-        // public bool manualInit;
+        [Tooltip("Automatically retry requesting ad if an ad failed to response in this amount of time (in secs)")]
         public int adLoadTimeoutInSecs = 60;
+        
+        [Tooltip("When an ad is not ready to show, keep waiting for this amount of time (in secs)\n\nIf the ad is ready during that time, it would be shown normally.")]
         public int adShowTimeoutInSecs = 5;
-        public BannerPosition bannerPosition = BannerPosition.BOTTOM;
-        public bool autoLogEvent = true;
+        
+        [Tooltip("When an ad is not ready to show, verify that there is an internet connection by ping the internet check URL .\nIf there is no internet connection, we will not need to wait for adShowTimeout secs")]
         public bool checkInternet = true;
-
-        public bool enableInterstitial = true;
-        public bool enableRewarded = true;
-        public bool enableBanner = true;
-
+                
+        [HideInInspector] public bool enableInterstitial = true;
+        [HideInInspector] public bool enableRewarded = true;
+        [HideInInspector] public bool enableBanner = true;
+        
+        [Tooltip("Before showing an ad: set AudioListener.volume to 0\nAfter the ad is closed: restore the previously saved AudioListener.volume")]
         public bool autoMute = true;
+        
+        [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;
 
         [Header("EDITOR")]
+        [Tooltip("Only applicable in Editor\n0 = 0% success\n1 = 100% success")]
         [Range(0f, 1f)] public float rewardAdShowSuccessRate = 1;
     }
 
@@ -399,14 +428,14 @@ namespace Amanotes.Core.Internal
         protected AdModuleConfig moduleConfig => Config.ad;
 
         // APIs
-        protected internal abstract AdLogic interstitial { get; }
-        protected internal abstract AdLogic rewardVideo { get; }
+        internal protected abstract AdLogic interstitial { get; }
+        internal protected abstract AdLogic rewardVideo { get; }
 
-        public abstract void ShowBanner(BannerPosition bannerPosition);
+        public abstract void ShowBanner();
         public abstract void HideBanner();
 
         // Internally used
-        protected internal abstract void SetUserId(string userId);
+        internal protected abstract void SetUserId(string userId);
     }
     
     public interface IAdCallback { }
@@ -443,13 +472,6 @@ namespace Amanotes.Core.Internal
         Fail = 256
     }
     
-    public enum BannerPosition
-    {
-        TOP = 1,
-        BOTTOM = 2,
-        RECTANGLE = 3
-    }
-
     public enum AdType
     {
         Interstitial,
@@ -643,7 +665,9 @@ namespace Amanotes.Core.Internal
 
             AdStat stat = Ads.localData.GetStat(adType);
             stat.callCount++;
-            stat.lastCallTime = Time.realtimeSinceStartup;
+            stat.prevCallTime = stat.currentCallTime;
+            stat.currentCallTime = Time.realtimeSinceStartup;
+            
             dispatcher.Dispatch(
                 _isInterstitial ? AmaGDK.Event.INTER_SHOW_CALLED : AmaGDK.Event.REWARD_VIDEO_SHOW_CALLED
             );

package/Runtime/AmaGDK.Analytics.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Text;
-using System.Text.RegularExpressions;
 using Amanotes.Core.Internal;
 using UnityEngine;
 using UnityEngine.Profiling;
@@ -1050,10 +1049,10 @@ namespace Amanotes.Core.Internal
     {
         // [Header("-----     MODULE CONFIG      -----")]
         public bool showAnalyticsLog;
-        public bool normalizeEventName = true;
-        public bool checkMigrationIntegrity = true;
-        public bool migrateAccumulatedCount = true;
-        public bool enableEventStat;
+        [HideInInspector] public bool normalizeEventName = true;
+        [HideInInspector] public bool checkMigrationIntegrity = true;
+        [HideInInspector] public bool migrateAccumulatedCount = true;
+        [HideInInspector] public bool enableEventStat;
         public AnalyticQualityConfig quality;
     }
     
@@ -1079,11 +1078,10 @@ namespace Amanotes.Core.Internal
     
     public abstract class AnalyticsAdapter : Adapter2
     {
-        public bool SendEventByDefault;
-
-        public List<string> NeverSend;
-        public List<string> AlwaysSend;
-
+        [HideInInspector] public List<string> NeverSend = new List<string>();
+        [HideInInspector] public List<string> AlwaysSend = new List<string>();
+        protected abstract bool SendEventByDefault { get; }
+        
         public bool IsForbidden(string eventName)
         {
             return SendEventByDefault

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -361,20 +361,6 @@ namespace Amanotes.Core
             }
         }
     }
-
-    // public static class RemoteConfigExtension
-    // {
-    //     public static void InitRemoteConfigModule(this RemoteConfigAdapter ap, Action<bool> onCompleteCallback)
-    //     {
-    //         if (AmaGDK.RemoteConfig.fetchState != AmaGDK.RemoteConfig.FetchState.None)
-    //         {
-    //             LogWarning($"[RemoteConfig] Current state {AmaGDK.RemoteConfig.fetchState.ToString()}\nCannot start to initialize");
-    //             return;
-    //         }
-    //         
-    //         AmaGDK.RemoteConfig.NextState();
-    //     }
-    // }
 }
 
 namespace Amanotes.Core.Internal
@@ -382,10 +368,13 @@ namespace Amanotes.Core.Internal
     [Serializable]
     public class RemoteConfigConfig
     {
-        // [Header("-----     MODULE CONFIG      -----")]
-
+        [Tooltip("Fetch timeout for first session (in secs)")]
         public float firstFetchTimeOutInSeconds = 10;
+        
+        [Tooltip("Fetch timeout for 2nd+ session (in secs)")]
         public float defaultTimeOutInSeconds = 3;
+        
+        [Tooltip("To create embed Remote config:\n\n- Right click in Project panel\n- Create > AmaGDK > Embed Remote Config\n- Drag & drop the asset here")]
         [SerializeField] internal EmbedRemoteConfigAsset embedRemoteConfig;
     }
     

package/Runtime/AmaGDK.UserProfile.cs

@@ -120,7 +120,17 @@ namespace Amanotes.Core
             {
                 get => _session;
             }
-            
+
+            public string Country
+            {
+                get => _country;
+                set
+                {
+                    _country = ValidateId(value, COUNTRY_CODE_PATTERN);
+                    SaveIfDirty();
+                }
+            }
+
             public void UpdateUserId()
             {
 #if UNITY_ANDROID
@@ -199,12 +209,15 @@ namespace Amanotes.Core
             private string _appsFlyerId;
             [SerializeField] 
             private string _installationId;
-            [SerializeField] 
+            [SerializeField]
             private int _session;
+            [SerializeField]
+            private string _country;
 
             private const string ALPHANUMERIC_HYPHEN_PATTERN = @"^(?=.*\d)(?=.*[a-zA-Z])(?=.*-).+$";
             private const string ALPHANUMERIC_PATTERN = @"^(?=.*\d)(?=.*[a-zA-Z])[a-zA-Z\d]+$";
             private const string NUMERIC_HYPHEN_PATTERN = @"^(?=.*\d)(?=.*-)[\d-]+$";
+            private const string COUNTRY_CODE_PATTERN = @"^[A-Z]{2}$";
             
             private const string AMA_DEVICE_ID_KEY = "ama_device_id";
 

package/Runtime/AmaGDK.cs

@@ -17,13 +17,14 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.56";
+        public const string VERSION = "0.2.58";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;
         internal static bool _allowInit = false;
         public bool autoInit = true;
-
+        internal static readonly GDKGeoLocation GeoLocation = new GDKGeoLocation();
+        internal static readonly GDKServerTime ServerTime = new GDKServerTime();
         private static ConfigAsset _config = null;
         
         public static partial class Event
@@ -173,7 +174,6 @@ namespace Amanotes.Core
             }
         }
         
-        
         IEnumerator InitRoutine()
         {
             if (Config == null)
@@ -192,12 +192,39 @@ namespace Amanotes.Core
             yield return InitAdapters(sb);
             
             StartModules();
+            
+            ConfigGeoLocation();
+            if (Config.enableServerTime)
+            {
+                ServerTime.UpdateTime();
+            }
+            
             dispatcher.Dispatch(Event.GDK_INIT_END);
             
             _status = Status.Ready;
             dispatcher.Dispatch(Event.GDK_READY);
             Debug.Log($"AmaGDK v{VERSION} | {READY} in {Time.realtimeSinceStartup - startTime:#0.00}s\n\n{sb}");
         }
+
+        private void ConfigGeoLocation()
+        {
+            if (Config.enableGeoLocation)
+            {
+                var countryCode = User.Country;
+                if (string.IsNullOrWhiteSpace(countryCode))
+                {
+                    GeoLocation.GetCountryCode(remoteCountryCode =>
+                    {
+                        User.Country = remoteCountryCode;
+                        GeoLocation.SetCountryCode(remoteCountryCode);
+                    });   
+                }
+                else
+                {
+                    GeoLocation.SetCountryCode(countryCode);
+                }
+            }
+        }
     }
 
     public partial class AmaGDK // PUBLIC APIS
@@ -461,4 +488,10 @@ namespace Amanotes.Core
             }
         }
     }
+    
+    public class GDKException : Exception
+    {
+        public GDKException() { }
+        public GDKException(string message) : base(message) { }
+    }
 }

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -182,4 +182,33 @@ namespace Amanotes.Core.Internal
     public interface IOnApplicationQuit { void OnApplicationQuit(); }
     public interface IOnApplicationFocus { void OnApplicationFocus(bool hasFocus); }
     public interface IOnFrameUpdate { void OnFrameUpdate(); }
+
+    public static class Utils
+    {
+        /// <summary>
+        /// Registers the list of server time providers.
+        /// </summary>
+        /// <param name="providers">List of server time providers implementing IServerTimeProvider interface or extending BaseServerTimeProvider.</param>
+        /// <remarks>
+        /// It is mandatory to call RegisterServerTimeProvider before initializing AmaGDK by calling AmaGDK.Init().
+        /// </remarks>
+        public static void RegisterServerTimeProvider(List<IServerTimeProvider> providers)
+        {
+            GDKUtils.ThrowIf(AmaGDK._status != Status.None, "Please call RegisterServerTimeProvider() before initializing AmaGDK by calling AmaGDK.Init()");
+            ServerTime.SetTimeProviders(providers);
+        }
+        
+        /// <summary>
+        /// Set the GeoLocation Provider.
+        /// </summary>
+        /// <param name="provider">provider implementing IGeoLocationProvider interface.</param>
+        /// <remarks>
+        /// It is mandatory to call SetGeoLocationProvider before initializing AmaGDK by calling AmaGDK.Init().
+        /// </remarks>
+        public static void SetGeoLocationProvider(IGeoLocationProvider provider)
+        {
+            GDKUtils.ThrowIf(AmaGDK._status != Status.None, "Please call SetGeoLocationProvider() before initializing AmaGDK by calling AmaGDK.Init()");
+            GeoLocation.SetGeoLocationProvider(provider);
+        }
+    }
 }

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -77,6 +77,42 @@ namespace Amanotes.Core.Internal
             // Check if each segment exists in the output string in the correct order
             return AreSegmentsPresentInOrder(segments, formattedString);
         }
+        
+        /// <summary>
+        /// Retrieves the current server time adjusted to the user's timezone.
+        /// </summary>
+        /// <returns>The current server time adjusted to the user's timezone if available; otherwise, null.</returns>
+        public static DateTime? GetServerTime()
+        {
+            return AmaGDK.ServerTime.GetTime();
+        }
+
+        /// <summary>
+        /// Asynchronously retrieves the current server time with a callback function, adjusted to the user's timezone.
+        /// </summary>
+        /// <param name="result">Callback function invoked with the server time adjusted to the user's timezone if available; otherwise, null is passed in case of network or server errors.</param>
+        public static void GetServerTime(Action<DateTime?> result)
+        {
+            AmaGDK.ServerTime.GetTime(result);
+        }
+
+        /// <summary>
+        /// Gets the country code.
+        /// </summary>
+        /// <returns>The country code if available; otherwise, null.</returns>
+        public static string GetCountryCode()
+        {
+            return AmaGDK.GeoLocation.GetCountryCode();
+        }
+        
+        /// <summary>
+        /// Gets the country code asynchronously with a callback function.
+        /// </summary>
+        /// <param name="result">Callback function to be invoked with the country code if available; otherwise, null will be passed in case of network or server errors.</param>
+        public static void GetCountryCode(Action<string> result)
+        {
+            AmaGDK.GeoLocation.GetCountryCode(result);
+        }
 
         static bool AreSegmentsPresentInOrder(string[] segments, string outputString)
         {
@@ -117,6 +153,12 @@ namespace Amanotes.Core.Internal
             segments[matches.Count] = template.Substring(lastIndex);
             return segments;
         }
+
+        internal static void ThrowIf(bool condition, string message)
+        {
+            if (condition)
+                throw new GDKException(message);
+        }
     }
     
     public static class GDKReflection

package/Runtime/Internal/AmaGDK.WebUtils.cs

@@ -151,6 +151,7 @@ namespace Amanotes.Core.Internal
 
     public partial class SDKConfig
     {
-        public string internetCheckUrl = "http://www.google.com";
+        [Tooltip("The URL we would use to ping to verify if the app is actually connected to the internet")]
+        public string internetCheckUrl = "http://clients3.google.com/generate_204";
     }
 }

package/Runtime/Internal/GDKGeoLocationcs.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace Amanotes.Core.Internal
+{
+    public partial class ConfigAsset
+    {
+        [SerializeField] public bool enableGeoLocation = true;
+    }
+
+    internal class GDKGeoLocation
+    {
+        private IGeoLocationProvider provider = new CountryIS_GeoLocationProvider();
+        private string localCountryCode;
+
+        public void SetGeoLocationProvider(IGeoLocationProvider provider)
+        {
+            this.provider = provider;
+        }
+        public string GetCountryCode()
+        {
+            GDKUtils.ThrowIf(!AmaGDK.Config.enableGeoLocation, "GeoLocation is disabled, Please enable it in the AmaGDKConfig");
+            return localCountryCode;
+        } 
+        
+        public void GetCountryCode(Action<string> result)
+        {
+            GDKUtils.ThrowIf(!AmaGDK.Config.enableGeoLocation, "GeoLocation is disabled, Please enable it in the AmaGDKConfig");
+            if (!string.IsNullOrWhiteSpace(localCountryCode))
+            {
+                result?.Invoke(localCountryCode);
+                return;
+            }
+            provider.FetchGeoLocation(data =>
+            {
+                result?.Invoke(data.countryCode?.ToUpper());
+                if (data.errorMessage != null)
+                    Logging.Log(data.errorMessage);
+            });
+        }
+
+        internal void SetCountryCode(string countryCode)
+        {
+            localCountryCode = countryCode;
+        }
+    }
+}
+
+namespace Amanotes.Core
+{
+    public class GeoLocationData
+    {
+        public string countryCode;
+        public string errorMessage;
+
+        public GeoLocationData(string countryCode, string errorMessage = null)
+        {
+            this.countryCode = countryCode;
+            this.errorMessage = errorMessage;
+        }
+
+        public static GeoLocationData WithErrorMessage(string message)
+        {
+            return new GeoLocationData(null, message);
+        }
+    }
+    
+    public interface IGeoLocationProvider
+    {
+        public void FetchGeoLocation(Action<GeoLocationData> result);
+    }
+    
+    public class CountryIS_GeoLocationProvider: IGeoLocationProvider
+    {
+        public const string URL = "https://api.country.is/";
+        [Serializable]
+        private class LocationData
+        {
+            public string country;
+        }
+        
+        void IGeoLocationProvider.FetchGeoLocation(Action<GeoLocationData> result)
+        {
+            AmaGDK._instance.StartCoroutine(FetchGeoLocationRoutine(result));
+        }
+        
+        private IEnumerator FetchGeoLocationRoutine(Action<GeoLocationData> result)
+        {
+            using (var request = UnityWebRequest.Get(URL))
+            {
+                yield return request.SendWebRequest();
+
+                if (request.result != UnityWebRequest.Result.Success)
+                {
+                    result?.Invoke(GeoLocationData.WithErrorMessage($"Error fetching location: {request.error}"));
+                    yield break;
+                }
+
+                try
+                {
+                    var data = ParseResponse(request.downloadHandler.text);
+                    result?.Invoke(data);
+                }
+                catch (Exception e)
+                {
+                    result?.Invoke(GeoLocationData.WithErrorMessage($"Error parsing location data: {e.Message}"));
+                }
+            }
+        }
+        
+        private GeoLocationData ParseResponse(string response)
+        {
+            var locationData = JsonUtility.FromJson<LocationData>(response);
+            return new GeoLocationData(locationData.country);
+        }
+    }
+}

package/Runtime/Internal/GDKGeoLocationcs.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aaf2bb28b9484523af7d43aa2f6fb36e
+timeCreated: 1711956851

package/Runtime/Internal/GDKServerTime.cs

@@ -0,0 +1,211 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace Amanotes.Core
+{
+    public class ServerTimeData
+    {
+        public DateTime? time;
+        public string errorMessage;
+
+        public ServerTimeData(DateTime time)
+        {
+            this.time = time;
+            errorMessage = null;
+        }
+
+        public ServerTimeData(string errorMessage)
+        {
+            time = null;
+            this.errorMessage = errorMessage;
+        }
+    }
+
+    public interface IServerTimeProvider
+    {
+        public void FetchServerTime(Action<ServerTimeData> result);
+    }
+
+    public abstract class BaseServerTimeProvider : IServerTimeProvider
+    {
+        public abstract string GetURL();
+        public abstract ServerTimeData ParseResponse(string response);
+
+        public void FetchServerTime(Action<ServerTimeData> result)
+        {
+            AmaGDK._instance.StartCoroutine(FetchTimeRoutine(result));
+        }
+        
+        private IEnumerator FetchTimeRoutine(Action<ServerTimeData> result)
+        {
+            using (var request = UnityWebRequest.Get(GetURL()))
+            {
+                yield return request.SendWebRequest();
+
+                if (request.result != UnityWebRequest.Result.Success)
+                {
+                    result?.Invoke(new ServerTimeData($"Error fetching time: {request.error}"));
+                    yield break;
+                }
+
+                result?.Invoke(ParseResponse(request.downloadHandler.text));
+            }
+        }
+    }
+
+    internal class WorldTimeServer_TimeProvider : BaseServerTimeProvider
+    {
+        private const string URL = "https://www.worldtimeserver.com/current_time_in_LA.aspx";
+
+        public override ServerTimeData ParseResponse(string response)
+        {
+            string startStr = "id=\"serverTimeStamp\" value=\"";
+            int startIndex = response.IndexOf(startStr) + startStr.Length;
+            string unixTimeStr = string.Empty;
+            char currentChar = char.MinValue;
+            for (int i = startIndex, n = response.Length; i < n; i++)
+            {
+                currentChar = response[i];
+                if (currentChar == '.' || currentChar == '\"') break;
+                unixTimeStr += currentChar;
+            }
+            if (long.TryParse(unixTimeStr, out long unixTime))
+            {
+                DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(unixTime);
+                return new ServerTimeData(dateTimeOffset.DateTime);
+            }
+            else
+            {
+                return new ServerTimeData("Error parsing WorldTimeServer data");
+            }
+        }
+        public override string GetURL()
+        {
+            return URL;
+        }
+    }
+
+    internal class WorldTimeAPI_TimeProvider : BaseServerTimeProvider
+    {
+        private const string URL = "https://worldtimeapi.org/api/ip";
+
+        [Serializable]
+        private class TimeData
+        {
+            public string datetime;
+        }
+
+        public override string GetURL()
+        {
+            return URL;
+        }
+
+        public override ServerTimeData ParseResponse(string response)
+        {
+            try
+            {
+                var data = JsonUtility.FromJson<TimeData>(response);
+                DateTime utcTime = DateTime.ParseExact(data.datetime, "yyyy-MM-dd'T'HH:mm:ss.ffffffzzz", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AdjustToUniversal);
+                return new ServerTimeData(utcTime);
+            }
+            catch (Exception e)
+            {
+                return new ServerTimeData($"Error parsing time data: {e.Message}");
+            }
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal 
+{
+    public partial class ConfigAsset
+    {
+        [SerializeField] public bool enableServerTime = true;
+    }
+
+    internal class GDKServerTime
+    {
+        private const float MAX_WAIT_TIME = 60;
+        private List<IServerTimeProvider> providers = new List<IServerTimeProvider>() { new WorldTimeAPI_TimeProvider(), new WorldTimeServer_TimeProvider() };
+        private int currentIndex = 0;
+        private IServerTimeProvider provider
+        {
+            get { return providers[currentIndex]; }
+        }
+
+        private DateTime? serverTime;
+        private float timeSinceFetchServerTime;
+        private int retryCount = 0;
+
+        internal GDKServerTime()
+        {
+        }
+
+        public void SetTimeProviders(List<IServerTimeProvider> providers)
+        {
+            GDKUtils.ThrowIf(providers == null || providers.Count == 0, "Server time providers list cannot be null or empty.");
+            this.providers = providers;
+            currentIndex = 0;
+        }
+
+        public DateTime? GetTime()
+        {
+            GDKUtils.ThrowIf(!AmaGDK.Config.enableServerTime, "ServerTime is disabled, Please enable it in the AmaGDKConfig");
+            if (serverTime == null)
+                return null;
+            float duration = Time.realtimeSinceStartup - timeSinceFetchServerTime;
+            return ((DateTime)serverTime).AddSeconds(duration);
+        }
+
+        public void GetTime(Action<DateTime?> result)
+        {
+            GDKUtils.ThrowIf(!AmaGDK.Config.enableServerTime, "ServerTime is disabled, Please enable it in the AmaGDKConfig");
+            if (serverTime == null)
+            {
+                UpdateTime(result);
+            }
+            else
+            {
+                result(GetTime());
+            }
+        }
+
+        public void UpdateTime(Action<DateTime?> result = null)
+        {
+            provider.FetchServerTime(data =>
+            {
+                if (data.time != null)
+                {
+                    serverTime = data.time;
+                    timeSinceFetchServerTime = Time.realtimeSinceStartup;
+                    result?.Invoke(data.time);
+                }
+                else
+                {
+                    result?.Invoke(null);
+                    Logging.Log(data.errorMessage);
+                    FetchTimeWithOtherProvider();
+                }
+            });
+        }
+
+        private void FetchTimeWithOtherProvider()
+        {
+            retryCount++;
+            currentIndex = (currentIndex + 1) % providers.Count;
+            if (retryCount < providers.Count)
+            {
+                UpdateTime();
+                return;
+            }
+            float waitTime = Mathf.Min(MAX_WAIT_TIME, Mathf.Pow(2, retryCount - providers.Count + 1));
+            GDKUtils.DelayCall(waitTime, () =>
+            {
+                UpdateTime();
+            });
+        }
+    }
+}

package/Runtime/Internal/GDKServerTime.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 04a5b0922db443b39ec9a3edeb2e3337
+timeCreated: 1711943237

package/Runtime/Klavar/Attributes/ToStringAttribute.cs

@@ -43,14 +43,22 @@ namespace Amanotes.Core
         {
             this.converter = converter;
         }
-
-        private string GetValueAsString(object enumVal)
+    
+        private string GetValueAsString(object fieldValue)
         {
-            // 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());
+            var fieldStringValue = fieldValue.ToString();
+            var fieldType = fieldValue.GetType();
+            if (fieldType.IsEnum)
+            {
+                var members = fieldType.GetMember(fieldStringValue);
+                if (members.Length > 0)
+                {
+                    var attribute = (ValueAttribute)GetCustomAttribute(members[0], typeof(ValueAttribute));
+                    if (attribute != null) 
+                        return convertMethods[converter](attribute.sValue);
+                }
+            }
+            return convertMethods[converter](fieldStringValue);
         }
 
         public override object Convert(object parent, FieldInfo fieldInfo, object param)

package/Runtime/Klavar/KlavarContainer.cs

@@ -11,9 +11,10 @@ namespace Amanotes.Core
         public string lastEventName;
 
         public static void LogEventError(string message)
-        {
-            if (!Application.isBatchMode)
-                Logging.LogError(message);
+        {    
+            #if !AMAGDK_DEV
+            Logging.LogError(message);
+            #endif
             throw new KlavarException(message);
         }
     }

package/Runtime/Klavar/KlavarEvent.cs

@@ -87,7 +87,7 @@ namespace Amanotes.Core
         {
             return this
                 .GetType()
-                .GetFields()
+                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                 .Where(field => field.GetCustomAttribute<IgnoreAttribute>() == null)
                 .Select(field => Validate(field))
                 .ToDictionary(

package/Runtime/Klavar/KlavarEventUtils.cs

@@ -39,14 +39,14 @@ namespace Amanotes.Core
         public static string ToCamelCase(string text)
         {
             var tokens = ToTokens(text);
-            return string.Join("", tokens.Select(t => Char.ToUpper(t[0]) + t.Substring(1).ToLower()));
+            return string.Join("", tokens.Select((t, i) =>
+                (i == 0 ? Char.ToLower(t[0]) : 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()));
+            return string.Join("", tokens.Select(t => Char.ToUpper(t[0]) + t.Substring(1).ToLower()));
         }
 
         public static string ToKebabCase(string text)

package/package.json

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