com.amanotes.gdk 0.1.20 → 0.2.1

package/Runtime/AmaGDK.Config.cs

@@ -2,12 +2,12 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 using UnityEngine;
-
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
 
-namespace Amanotes.Core.Internal {
+namespace Amanotes.Core.Internal
+{
     public partial class ConfigAsset : ScriptableObject
     {
         [SerializeField] internal bool simpleOrder = true;
@@ -15,63 +15,67 @@ namespace Amanotes.Core.Internal {
         [SerializeField] public SDKConfig common;
 
 #if UNITY_EDITOR
-        void OnValidate()
+        private void OnValidate()
         {
             if (Application.isPlaying) return;
-            if (simpleOrder) {
+            if (simpleOrder)
+            {
                 EditorApplication.update -= DelayCheckOrder;
                 EditorApplication.update += DelayCheckOrder;
             }
         }
 
-        void DelayCheckOrder()
+        private void DelayCheckOrder()
         {
             EditorApplication.update -= DelayCheckOrder;
             var dirty = false;
-            for (var i =0 ;i < initOrder.Count;i++){
+            for (var i = 0; i < initOrder.Count; i++)
+            {
                 if (initOrder[i].order == i) continue;
                 dirty = true;
                 break;
             }
 
             if (!dirty) return;
-            initOrder.Sort((a1, a2)=> a1.order.CompareTo(a2.order));
-            for (var i =0 ;i < initOrder.Count;i++){
+            initOrder.Sort((a1, a2) => a1.order.CompareTo(a2.order));
+            for (var i = 0; i < initOrder.Count; i++)
+            {
                 initOrder[i].order = i;
             }
             EditorUtility.SetDirty(this);
         }
 
         [ContextMenu("Scan Adapters")]
-        void ScanAdapters()
+        private void ScanAdapters()
         {
             initOrder.Clear();
 
             var counter = 0;
-            foreach (var adapter in GetAllAdapters<AdapterContext>())
+            foreach (Type adapter in GetAllAdapters<AdapterContext>())
             {
-                var id = adapter.Name.Replace("Adapter", string.Empty);
+                string id = adapter.Name.Replace("Adapter", string.Empty);
                 initOrder.Add(new InitOrder(){ id = id, order = counter++ });
             }
         }
 
         [ContextMenu("Refresh Order")]
-        void UpdateOrderToPosition()
+        private void UpdateOrderToPosition()
         {
-            for (var i =0 ;i < initOrder.Count; i++)
+            for (var i = 0; i < initOrder.Count; i++)
             {
                 initOrder[i].order = i;
             }
         }
-        
+
         public static IEnumerable<Type> GetAllAdapters<T>()
         {
-            var typeT = typeof(T);
+            Type typeT = typeof(T);
             foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
             {
                 if (!a.FullName.Contains("Assembly-CSharp")) continue;
-                
-                foreach (var type in a.GetTypes()){
+
+                foreach (Type type in a.GetTypes())
+                {
                     if (typeT.IsAssignableFrom(type)) yield return type;
                 }
             }
@@ -82,7 +86,7 @@ namespace Amanotes.Core.Internal {
     [Serializable]
     public partial class SDKConfig
     {
-        public bool verboseLog = false;
+        public bool verboseLog;
     }
 
     [Serializable]
@@ -91,4 +95,4 @@ namespace Amanotes.Core.Internal {
         public string id;
         public int order;
     }
-}
+}

package/Runtime/AmaGDK.Internal.SemVer.cs

@@ -29,14 +29,11 @@ namespace Amanotes.Core.Internal
             patch = 0;
             extra = -1;
 
-            if (string.IsNullOrEmpty(version))
-            {
-                return;
-            }
+            if (string.IsNullOrEmpty(version)) return;
 
             version = version.Trim();
 
-            Regex regex = new Regex(@"^(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?$");
+            var regex = new Regex(@"^(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?$");
             Match match = regex.Match(version);
             if (!match.Success)
             {
@@ -51,10 +48,10 @@ namespace Amanotes.Core.Internal
                 if (!int.TryParse(match.Groups[4].Value, out extra))
                     extra = -1;
             }
-                
+
         }
 
-        public bool isValid { get { return this != ZERO; } }
+        public bool isValid => this != ZERO;
 
         public override string ToString()
         {
@@ -65,22 +62,10 @@ namespace Amanotes.Core.Internal
 
         public int CompareTo(SemVer other)
         {
-            if (major != other.major)
-            {
-                return major.CompareTo(other.major);
-            }
-            if (minor != other.minor)
-            {
-                return minor.CompareTo(other.minor);
-            }
-            if (patch != other.patch)
-            {
-                return patch.CompareTo(other.patch);
-            }
-            if (extra != other.extra)
-            {
-                return extra.CompareTo(other.extra);
-            }
+            if (major != other.major) return major.CompareTo(other.major);
+            if (minor != other.minor) return minor.CompareTo(other.minor);
+            if (patch != other.patch) return patch.CompareTo(other.patch);
+            if (extra != other.extra) return extra.CompareTo(other.extra);
             return 0;
         }
 
@@ -91,11 +76,8 @@ namespace Amanotes.Core.Internal
 
         public override bool Equals(object obj)
         {
-            if (!(obj is SemVer))
-            {
-                return false;
-            }
-            SemVer other = (SemVer)obj;
+            if (!(obj is SemVer)) return false;
+            var other = (SemVer)obj;
             return major == other.major && minor == other.minor && patch == other.patch && extra == other.extra;
         }
 
@@ -134,4 +116,4 @@ namespace Amanotes.Core.Internal
             return (major << 24) | (minor << 16) | (patch << 8) | extra;
         }
     }
-}
+}

package/Runtime/AmaGDK.Internal.cs

@@ -1,6 +1,6 @@
-using System.Text;
+using System;
 using System.Collections.Generic;
-
+using System.Text;
 using UnityEngine;
 using UnityObject = UnityEngine.Object;
 using static Amanotes.Core.AmaGDK.Analytics;
@@ -39,11 +39,13 @@ namespace Amanotes.Core.Internal
         public const string AMAGDK_PREFAB = BASE_PATH + "Runtime/AmaGDK.prefab";
         public const string AMAGDK_CONFIG_PACKAGE = PACKAGE_PATH + "AmaGDKConfig.unitypackage";
 
-        public static readonly string[] AMAGDK_ADAPTERS = new string[]
+        public static readonly string[] AMAGDK_ADAPTERS =
         {
             "FirebaseAnalyticsAdapter_v9.1.0",
             "AppsFlyerAdapter_v6.5.4",
+
             // "IronsourceAdapter_v7.2.6",
+            "FirebaseRemoteConfigAdapter_v9.1.0"
         };
 
 #if UNITY_EDITOR
@@ -51,14 +53,14 @@ namespace Amanotes.Core.Internal
         [MenuItem("GameObject/AmaGDK/Add AmaGDK Prefab", false, 10)]
         private static void AddAmaGDKPrefab()
         {
-            GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(AMAGDK_PREFAB);
+            var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(AMAGDK_PREFAB);
             if (prefab == null)
             {
                 Debug.LogWarning($"Prefab [AmaGDK] not found at: {AMAGDK_PREFAB}");
                 return;
             }
 
-            GameObject newPrefab = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
+            var newPrefab = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
             newPrefab.name = "AmaGDK";
             newPrefab.transform.SetAsLastSibling();
             Selection.activeObject = null;
@@ -67,7 +69,6 @@ namespace Amanotes.Core.Internal
 #endif
     }
 
-
     public static class Logging
     {
         public static readonly StringBuilder tmpWarningSB = new StringBuilder();
@@ -104,14 +105,14 @@ namespace Amanotes.Core.Internal
                 AmaGDK._instance = null;
             }
 
-            var result = Resources.FindObjectsOfTypeAll<AmaGDK>();
+            AmaGDK[] result = Resources.FindObjectsOfTypeAll<AmaGDK>();
             for (var i = 0; i < result.Length; i++)
             {
                 if (result[i] == null) continue;
 
 #if UNITY_EDITOR // Ignore loaded prefabs assets
                 {
-                    var path = UnityEditor.AssetDatabase.GetAssetPath(result[i]);
+                    string path = AssetDatabase.GetAssetPath(result[i]);
                     if (!string.IsNullOrEmpty(path)) continue;
                 }
 #endif
@@ -129,10 +130,15 @@ namespace Amanotes.Core.Internal
 
         public static void ClearAnalyticsData()
         {
-            AnalyticsData analyticsData = AmaGDK.Analytics.localData;
+            AnalyticsData analyticsData = localData;
             analyticsData.funnelSignatures.Clear();
             analyticsData.eventDetails.Clear();
-            analyticsData.migrationLog = new AmaGDK.Analytics.MigrationLog();
+            analyticsData.migrationLog = new MigrationLog();
         }
     }
-}
+    
+    public interface IOnApplicationPause { void OnApplicationPause(bool pauseStatus); }
+    public interface IOnApplicationQuit { void OnApplicationQuit(); }
+    public interface IOnApplicationFocus { void OnApplicationFocus(bool hasFocus); }
+    public interface IOnFrameUpdate { void OnFrameUpdate(); }
+}

package/Runtime/AmaGDK.RemoteConfig.cs

@@ -0,0 +1,352 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using UnityEngine;
+
+using Amanotes.Core.Internal;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK //Remote Config
+    {
+        public enum RemoteConfigSource
+        {
+            DefaultAsset,
+            DefaultFile,
+            Cache,
+            Internet
+        }
+
+        [Serializable]
+        public partial class RemoteConfig //Public
+        {
+            public static Action<bool> onFetchCompleted;
+            public static Dictionary<string, string> DictConfig { get { return dictConfig; } }
+            public static RemoteConfigSource Source { private set; get; }
+            static bool? _cacheExisted = null;
+            public static bool HasCache
+            {
+                get
+                {
+                    if (_cacheExisted == null)
+                        _cacheExisted = FileUtils.Exist(fileName);
+                    return _cacheExisted.GetValueOrDefault();
+                }
+            }
+
+            internal static T ParseConfig<T>(T config = null) where T : class, new()
+            {
+                if (config == null)
+                    config = new T();
+
+                var configInJson = GetConfigAsJsonString();
+                if (string.IsNullOrEmpty(configInJson))
+                {
+                    LogWarning("[RemoteConfig] The config is empty");
+                    return config;
+                }
+
+                try
+                {
+                    return config = JsonUtility.FromJson<T>(configInJson);
+                }
+                catch (Exception e)
+                {
+                    LogError("[RemoteConfig] Cannot parse remote config file. Error: " + e.Message);
+                    return config;
+                }
+            }
+
+            public static T Get<T>(string key, T defaultValue = default(T))
+            {
+                if (dictConfig.ContainsKey(key))
+                    return (T)Convert.ChangeType(dictConfig[key], typeof(T));
+                return defaultValue;
+            }
+
+            public static T WriteConfigTo<T>(T config = null) where T : class, new ()
+            {
+                return ParseConfig<T>(config);
+            }
+
+            public static string GetConfigAsJsonString()
+            {
+                return JsonUtils.DictionaryToJson(dictConfig);
+            }
+        }
+
+        public partial class RemoteConfig //Internal
+        {
+            internal enum FetchState
+            {
+                None,
+                ResolveDependencies,
+                CheckInternet,
+                Fetch,
+                SaveCache,
+
+                LoadCache,
+                LoadDefaultFile,
+                LoadDefaultAsset,
+
+                Success,
+                Fail
+            }
+
+            static Dictionary<string, string> dictConfig = new Dictionary<string, string>();
+            static string fileName = $"{nameof(RemoteConfig)}.kv";
+            static string defaultConfigFileName = "remote_config_defaults";
+
+            static FetchState _state = FetchState.None;
+            internal static FetchState State { get { return _state; } }
+            static readonly Dictionary<FetchState, Action[]> fetchSM = new Dictionary<FetchState, Action[]>
+            {
+                { FetchState.None,                new Action[]{ ResolveDependency }},
+                { FetchState.ResolveDependencies, new Action[]{ LoadCache, CheckInternet}},
+                { FetchState.CheckInternet,       new Action[]{ LoadCache, Fetch}},
+                { FetchState.Fetch,               new Action[]{ LoadCache, SaveCache}},
+                { FetchState.SaveCache,           new Action[]{ SetDone }},
+                { FetchState.LoadCache,           new Action[]{ LoadDefaultFile, SetDone}},
+                { FetchState.LoadDefaultFile,     new Action[]{ LoadDefaultAsset, SetDone}},
+                { FetchState.LoadDefaultAsset,    new Action[]{ SetFail, SetDone}}
+            };
+
+            internal static IRemoteConfig adapter;
+            internal static Action<bool> onAdapterInitCompleteCallback;
+
+            internal static void NextState(bool result = true)
+            {
+                if (!fetchSM.TryGetValue(_state, out var actions))
+                {
+                    LogWarning("[RemoteConfig] Invalid / Unsupported state: " + _state);
+                    return;
+                }
+
+                if (actions.Length == 1)
+                {
+                    actions[0]();
+                    return;
+                }
+
+                actions[result ? 1 : 0]();
+            }
+
+            static void ResolveDependency()
+            {
+                _state = FetchState.ResolveDependencies;
+                adapter = Adapter.GetSingleAdapter<IRemoteConfig>();
+                if (adapter == null)
+                {
+                    NextState(false);
+                    return;
+                }
+                adapter.ResolveDependencies(NextState);
+            }
+
+            static void CheckInternet()
+            {
+                _state = FetchState.CheckInternet;
+                NextState(Application.internetReachability != NetworkReachability.NotReachable);
+            }
+
+            static void Fetch()
+            {
+                _state = FetchState.Fetch;
+                adapter.FetchConfig(HasCache, (isSuccess, result) =>
+                {
+                    if (!isSuccess)
+                    {
+                        NextState(false);
+                        return;
+                    }
+
+                    dictConfig = result;
+                    Source = RemoteConfigSource.Internet;
+                    Log("[RemoteConfig] Load from the internet");
+                    NextState(true);
+                });
+            }
+
+            static void SaveCache()
+            {
+                _state = FetchState.SaveCache;
+                StringBuilder sb = new StringBuilder();
+                foreach (var c in dictConfig)
+                {
+                    sb.AppendLine($"{c.Key}\t{c.Value}");
+                }
+
+                var filePath = FileUtils.GetPath(fileName);
+                FileUtils.Save(filePath, sb.ToString());
+                Log($"[RemoteConfig] Saved remote config to {filePath}");
+                NextState();
+            }
+
+            static void LoadCache()
+            {
+                _state = FetchState.LoadCache;
+
+                if (!HasCache)
+                {
+                    NextState(false);
+                    return;
+                }
+
+                try
+                {
+                    dictConfig.Clear();
+                    using (StreamReader sr = new StreamReader(FileUtils.GetPath(fileName)))
+                    {
+                        string line;
+                        int lineIdx = 0;
+                        while ((line = sr.ReadLine()) != null)
+                        {
+                            lineIdx++;
+                            var idx = line.IndexOf('\t');
+                            if (idx == -1)
+                            {
+                                LogWarning($"[RemoteConfig] Cannot get (key, value) at line {lineIdx} of cache");
+                                continue;
+                            }
+                            string key = line.Substring(0, idx);
+                            string value = line.Substring(idx + 1);
+                            dictConfig.Add(key, value);
+                        }
+                    }
+                    Source = RemoteConfigSource.Cache;
+                    Log("[RemoteConfig] Load from cache");
+                }
+                catch (Exception ex)
+                {
+                    LogWarning($"[RemoteConfig] Error on LoadCache: {ex.Message}");
+                    _cacheExisted = false;
+                    NextState(false);
+                    return;
+                }
+
+                NextState(true);
+            }
+
+            static void LoadDefaultFile()
+            {
+                _state = FetchState.LoadDefaultFile;
+
+                var defaultConfigFile = Resources.Load<TextAsset>(defaultConfigFileName);
+                if (defaultConfigFile == null)
+                {
+                    NextState(false);
+                    return;
+                }
+
+                dictConfig = JsonToDictionary(defaultConfigFile.text);
+
+                Source = RemoteConfigSource.DefaultFile;
+                Log("[RemoteConfig] Load from default file");
+                NextState(true);
+            }
+
+            static void LoadDefaultAsset()
+            {
+                _state = FetchState.LoadDefaultAsset;
+
+                var defaultValue = ((AdapterContext)adapter).GetAdapterConfig<RemoteConfigConfig>().defaultValue;
+
+                if (defaultValue.Length == 0)
+                {
+                    NextState(false);
+                    return;
+                }
+
+                foreach (var item in defaultValue)
+                {
+                    dictConfig.Add(item.key, item.value);
+                }
+                Source = RemoteConfigSource.DefaultAsset;
+                Log("[RemoteConfig] Load from default asset");
+                NextState(true);
+            }
+
+            static void SetDone()
+            {
+                _state = FetchState.Success;
+                onAdapterInitCompleteCallback(true);
+                onFetchCompleted?.Invoke(true);
+            }
+
+            static void SetFail()
+            {
+                _state = FetchState.Fail;
+                onAdapterInitCompleteCallback(false);
+                onFetchCompleted?.Invoke(false);
+            }
+
+            static Dictionary<string, string> JsonToDictionary(string json)
+            {
+                var dictResult = new Dictionary<string, string>();
+                string[] lines = json.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                for (int i = 0; i < lines.Length; i++)
+                {
+                    int idx = lines[i].IndexOf(':');
+                    if (idx < 0)
+                    {
+                        continue;
+                    }
+                    string key = lines[i].Substring(0, idx - 1).Trim().Trim('"');
+                    string value = "";
+                    if (idx == lines.Length - 1)
+                    {
+                        value = lines[i].Substring(idx + 1).Trim().Trim('"');
+                    }
+                    else
+                    {
+                        value = lines[i].Substring(idx + 1).Trim();
+                        value = value.Substring(1, value.Length - 3);
+                    }
+                    dictResult[key] = value;
+                }
+                return dictResult;
+            }
+        }
+    }
+
+    public static class RemoteConfigExtension
+    {
+        public static void InitRemoteConfigModule(this IRemoteConfig ap, Action<bool> onCompleteCallback)
+        {
+            if (AmaGDK.RemoteConfig.State != AmaGDK.RemoteConfig.FetchState.None)
+            {
+                LogWarning($"[RemoteConfig] Current state {AmaGDK.RemoteConfig.State.ToString()}\n" +
+                           $"Cannot start to initialize");
+                return;
+            }
+            AmaGDK.RemoteConfig.onAdapterInitCompleteCallback = onCompleteCallback;
+            AmaGDK.RemoteConfig.NextState();
+        }
+    }
+}
+
+namespace Amanotes.Core.Internal
+{
+    [Serializable]
+    public class RemoteConfigConfig
+    {
+        public KeyValue[] defaultValue;
+        public float firstFetchTimeOutInSeconds = 10;
+        public float defaultTimeOutInSeconds = 3;
+    }
+
+    [Serializable]
+    public class KeyValue
+    {
+        public string key;
+        public string value;
+    }
+
+    public interface IRemoteConfig
+    {
+        void ResolveDependencies(Action<bool> onComplete);
+        void FetchConfig(bool isFirstTime, Action<bool, Dictionary<string, string>> onComplete);
+    }
+}

package/Runtime/{AmaPassport/Plugins/Android/AdvertisingIdFetcher.cs.meta → AmaGDK.RemoteConfig.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: c5087255689cb4759b97b4acc6948b43
+guid: d81aa5ad940bd43139879d9d53e0e00b
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/AmaGDK.UserProfile.cs

@@ -1,8 +1,6 @@
 using System;
 using Amanotes.Core.Internal;
 using UnityEngine;
-using FileUtils = Amanotes.Core.Internal.FileUtils;
-
 namespace Amanotes.Core
 {
     public partial class AmaGDK //User profile
@@ -10,10 +8,10 @@ namespace Amanotes.Core
         public static readonly UserProfile User = new UserProfile().Load();
 
         [Serializable]
-        public partial class UserProfile: IJsonFile
+        public partial class UserProfile : IJsonFile
         {
-            [NonSerialized] internal bool _dirty = false;
-            const string FILE_NAME = nameof(UserProfile);
+            private const string FILE_NAME = nameof(UserProfile);
+            [NonSerialized] internal bool _dirty;
 
             public void Save()
             {
@@ -22,9 +20,8 @@ namespace Amanotes.Core
 
             public UserProfile Load()
             {
-                var json = FileUtils.Load(FILE_NAME);
-                if (string.IsNullOrEmpty(json))
-                    return this;
+                string json = FileUtils.Load(FILE_NAME);
+                if (string.IsNullOrEmpty(json)) return this;
                 JsonUtility.FromJsonOverwrite(json, this);
                 return this;
             }