com.amanotes.gdk 0.2.57 → 0.2.58

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # 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

package/Runtime/AmaGDK.Ads.cs

@@ -11,6 +11,9 @@ 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;
@@ -19,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;
@@ -27,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;
@@ -35,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;
@@ -43,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;
@@ -51,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;
@@ -59,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;
@@ -67,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;
@@ -77,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)
         {
@@ -124,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;
@@ -154,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)
@@ -626,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.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.57";
+        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/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/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/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.57",
+    "version": "0.2.58",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",