com.amanotes.gdk 0.2.13 → 0.2.16

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.2.14 - 2023-08-08]
+### Support multiple embed remote config and load config by id
+### Clear cached remote config on new app update
+### Override remote config value in editor mode
+### New feature: Analytics Quality
+
 ## [0.2.13 - 2023-07-20]
 ### Fix error Remote Config JSON caused by special chars (", ', \)
 

package/Editor/EmbedRemoteConfigAssetInspector.cs

@@ -0,0 +1,191 @@
+using System;
+using System.Text;
+using Amanotes.Core.Internal;
+using UnityEditor;
+using UnityEngine;
+
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Editor
+{
+    [CustomEditor(typeof(EmbedRemoteConfigAsset))]
+    internal class EmbedRemoteConfigAssetInspector : UnityEditor.Editor
+    {
+        private EmbedRemoteConfigAsset remoteConfigAsset;
+        private SerializedProperty overrideInEditorProperty;
+        private SerializedProperty overrideConfigProperty;
+        private SerializedProperty configsProperty;
+        private bool[] foldouts;
+        
+        private void OnEnable()
+        {
+            remoteConfigAsset = (EmbedRemoteConfigAsset)target;
+            overrideInEditorProperty = serializedObject.FindProperty("overrideInEditor");
+            overrideConfigProperty = serializedObject.FindProperty("overrideConfig");
+            configsProperty = serializedObject.FindProperty("configs");
+            foldouts = new bool[configsProperty.arraySize];
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Active Id:");
+            EditorGUILayout.LabelField(remoteConfigAsset.activeId);
+            EditorGUILayout.EndHorizontal();
+            
+            serializedObject.Update();
+            
+            DrawPropertiesExcluding(serializedObject, "m_Script", "activeId", "configs", "overrideConfig");
+            
+            if (overrideInEditorProperty.boolValue)
+            {
+                EditorGUILayout.PropertyField(overrideConfigProperty);
+            }
+            
+            if (GUILayout.Button("Add a config set"))
+            {
+                configsProperty.arraySize++;
+                int lastIndex = configsProperty.arraySize - 1;
+                var config= configsProperty.GetArrayElementAtIndex(lastIndex);
+                config.FindPropertyRelative("id").stringValue = $"config{lastIndex}";
+                foldouts = AddElementToArray(foldouts, false);
+            }
+            
+            for (int i = 0; i < configsProperty.arraySize; i++)
+            {
+                SerializedProperty configProperty = configsProperty.GetArrayElementAtIndex(i);
+                SerializedProperty idProperty = configProperty.FindPropertyRelative("id");
+                SerializedProperty fetchUrlProperty = configProperty.FindPropertyRelative("fetchUrl");
+                SerializedProperty itemsProperty = configProperty.FindPropertyRelative("items");
+
+                EditorGUILayout.BeginVertical(GUI.skin.box);
+                foldouts[i] = EditorGUILayout.Foldout(foldouts[i], idProperty.stringValue);
+                if (foldouts[i])
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.BeginHorizontal();
+                    if (GUILayout.Button("Set active", GUILayout.MinWidth(100)))
+                    {
+                        remoteConfigAsset.SetActiveConfig(idProperty.stringValue);
+                    }
+                    if (GUILayout.Button("Fetch", GUILayout.MinWidth(80)))
+                    {
+                        var url = fetchUrlProperty.stringValue;
+                        var currentConfigIndex = i;
+                        if (string.IsNullOrWhiteSpace(url))
+                        {
+                            ShowError("Please fill the fetch URL first");
+                        }
+                        else
+                        {
+                            WebRequest.Get(url, onProgress: FetchProgress, onSuccess: s => FillEmbedConfig(currentConfigIndex, s), onError:ShowError);
+                        }
+                    }
+                    if (GUILayout.Button("Remove", GUILayout.MinWidth(80)))
+                    {
+                        if (remoteConfigAsset.ActiveConfig?.id == idProperty.stringValue)
+                        {
+                            remoteConfigAsset.SetActiveConfig(string.Empty);
+                        }
+                        configsProperty.DeleteArrayElementAtIndex(i);
+                        foldouts = RemoveElementAtIndex(foldouts, i);
+                    }
+                    if (GUILayout.Button("Copy", GUILayout.MinWidth(80)))
+                    {
+                        GUIUtility.systemCopyBuffer = KeyValueToText(itemsProperty);
+                    }
+                    if (GUILayout.Button("Paste", GUILayout.MinWidth(80)))
+                    {
+                        FillEmbedConfig(i, GUIUtility.systemCopyBuffer);
+                    }
+                    EditorGUILayout.EndHorizontal();
+                    EditorGUILayout.PropertyField(idProperty);
+                    EditorGUILayout.PropertyField(fetchUrlProperty);
+                    EditorGUILayout.PropertyField(itemsProperty);
+
+                    EditorGUI.indentLevel--;
+                }
+                EditorGUILayout.EndVertical();
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+        }
+        
+        private T[] AddElementToArray<T>(T[] array, T element)
+        {
+            T[] newArray = new T[array.Length + 1];
+            array.CopyTo(newArray, 0);
+            newArray[array.Length] = element;
+            return newArray;
+        }
+
+        private T[] RemoveElementAtIndex<T>(T[] array, int index)
+        {
+            T[] newArray = new T[array.Length - 1];
+            for (int i = 0, j = 0; i < array.Length; i++)
+            {
+                if (i != index)
+                {
+                    newArray[j] = array[i];
+                    j++;
+                }
+            }
+            return newArray;
+        }
+
+        private void FetchProgress(float progress)
+        {
+            EditorUtility.DisplayProgressBar("Fetching default remote config", "Please wait...", progress);
+        }
+        
+        private void FillEmbedConfig(int configIndex, string rawText)
+        {
+            try
+            {
+                string[] lines = rawText.Split('\n');
+                KeyValue[] arrKeyValue = new KeyValue[lines.Length];
+                for (int i = 0; i < lines.Length; i++)
+                {
+                    var line = lines[i];
+                    var idx = line.IndexOf('\t');
+                    if (idx == -1)
+                    {
+                        LogWarning($"[RemoteConfig] Cannot get (key, value) at line {i+1}. Content:\n<{line}>");
+                        continue;
+                    }
+                    arrKeyValue[i] = new KeyValue
+                    {
+                        key = line.Substring(0, idx),
+                        value = line.Substring(idx + 1)
+                    };
+                }
+                remoteConfigAsset.configs[configIndex].items = arrKeyValue;
+            }
+            catch (Exception e)
+            {
+                LogWarning(e.Message);
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
+        private string KeyValueToText(SerializedProperty items)
+        {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < items.arraySize; i++)
+            {
+                SerializedProperty c = items.GetArrayElementAtIndex(i);
+                sb.AppendLine($"{c.FindPropertyRelative("key").stringValue}\t{c.FindPropertyRelative("value").stringValue}");
+            }
+            return sb.ToString();
+        }
+
+        private void ShowError(string error)
+        {
+            EditorUtility.ClearProgressBar();
+            EditorUtility.DisplayDialog("Error", error, "OK");
+        }
+    }
+}

package/Editor/EmbedRemoteConfigAssetInspector.cs.meta

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

package/Editor/MatchSDKVersion.cs

@@ -0,0 +1,151 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using System.IO;
+using System.Linq;
+using System;
+using System.Text.RegularExpressions;
+using Amanotes.Core.Internal;
+using Amanotes.Editor;
+
+namespace Amanotes.Core
+{
+    internal class MatchSDKVersion
+    {
+        private static string defineVer = "#define VER_";
+        private static string comment = "//";
+
+        private static Dictionary<string, string> sdkToClassMap = new Dictionary<string, string>
+        {
+            { "FirebaseAnalytics", "FirebaseAnalyticsAdapter" },
+            { "FirebaseRemoteConfig", "FirebaseRemoteConfigAdapter" },
+            { "appsflyer-unity-plugin", "AppsFlyerAdapter" },
+            { "IronSource_IntegrationManager", "IronSourceAdapter" },
+            { "Adjust", "AdjustAdapter" },
+            { "Purchases", "RevenueCatAdapter" }
+        };
+        
+        private static FileInfo[] files = null;
+
+        [InitializeOnLoadMethod]
+        private static void Initialize()
+        {
+            AssetDatabase.importPackageCompleted += UpdateAdapter;
+        }
+        private static void UncommentDefineAtLine(string filePath, int lineIndex)
+        {
+            string[] lines = File.ReadAllLines(filePath);
+
+            for (int i = 0; i < lines.Length; i++)
+            {
+                if (i == lineIndex)
+                {
+                    lines[i] = lines[i].TrimStart(new[] { '/', ' ' });
+                }
+                else if (Regex.IsMatch(lines[i], @"^#define\s+"))
+                {
+                    lines[i] = "//" + lines[i];
+                }
+            }
+
+            File.WriteAllLines(filePath, lines);
+        }
+
+        private static KeyValuePair<int, SemVer> FindNearestLowerVersion(SemVer inputVersion, Dictionary<int, SemVer> defineLines)
+        {
+            KeyValuePair<int, SemVer> versionLessAndNearest = default;
+            SemVer bestMatch = SemVer.ZERO;
+            
+            foreach (var kvp in defineLines)
+            {
+                if(inputVersion.CompareTo(kvp.Value) < 0)
+                    continue;
+                if(kvp.Value.CompareTo(bestMatch) <= 0)
+                    continue;
+                    
+                bestMatch = kvp.Value;
+                versionLessAndNearest = kvp;
+            }
+
+            return versionLessAndNearest;
+        }
+        
+        private static Dictionary<int, SemVer> GetSemVersDefine(string code)
+        {
+            Dictionary<int, SemVer> defineLines = new Dictionary<int, SemVer>();
+
+            string[] lines = code.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
+            for (int i = 0; i < lines.Length; i++)
+            {
+                string line = lines[i].Trim();
+
+                if (Regex.IsMatch(line, @"^(\/\/\s*)?#define\s+"))
+                {
+                    defineLines.Add(i, new SemVer(GetVersionNumber(line)));
+                }
+            }
+
+            return defineLines;
+        }
+
+        private static string GetVersionNumber(string defineString)
+        {
+            string pattern = @"VER_(\d+)_(\d+)_(\d+)";
+
+            Match match = Regex.Match(defineString, pattern);
+
+            if (match.Success)
+            {
+                string major = match.Groups[1].Value;
+                string minor = match.Groups[2].Value;
+                string patch = match.Groups[3].Value;
+                string versionNumber = $"{major}.{minor}.{patch}";
+
+                return versionNumber;
+            }
+
+            return string.Empty;
+        }
+
+        private static void UpdateAdapter(string packageName)
+        {
+            if (files == null)
+            {
+                string dataPath = Path.Combine(Application.dataPath, "AmaGDK/Adapters");
+                if (!Directory.Exists(dataPath))
+                {
+                    Logging.Log($"{dataPath} is not found");
+                    return;
+                }
+                DirectoryInfo directory = new DirectoryInfo(dataPath);
+                files = directory.GetFiles("*Adapter.cs", SearchOption.AllDirectories);
+            }
+
+            if (sdkToClassMap.TryGetValue(GetSDKName(packageName), out string adapterClass))
+            {
+                var version = SDKStatus.Get(adapterClass.Replace("Adapter", "")).sdkVersion;
+                FileInfo file = files.FirstOrDefault(x => x.FullName.Contains($"{adapterClass}.cs"));
+
+                if (file != null)
+                {
+                    Dictionary<int, SemVer> defineLines = GetSemVersDefine(File.ReadAllText(file.FullName));
+
+                    KeyValuePair<int, SemVer> r = FindNearestLowerVersion(version, defineLines);
+                    
+                    if (r.Value.isValid)
+                    {
+                        return;
+                    }
+                    UncommentDefineAtLine(file.FullName, r.Key);
+                }
+            }
+
+            AssetDatabase.Refresh();
+        }
+
+        private static string GetSDKName(string packageName)
+        {
+            return sdkToClassMap.Keys.FirstOrDefault(sdk => packageName.Contains(sdk));
+        }
+    }
+}

package/Editor/MatchSDKVersion.cs.meta

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

package/Editor/Utils/AmaGDKEditor.ExtractVersion.cs

@@ -24,7 +24,7 @@ namespace Amanotes.Editor
         }
     }
 
-    [Serializable] internal class SDKStatus
+    [Serializable] public class SDKStatus
     {
 
         // 

package/Editor/Utils/AmaGDKEditor.Utils.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.Networking;
+
 namespace Amanotes.Editor
 {
     internal static class Utils
@@ -31,4 +34,53 @@ namespace Amanotes.Editor
             EditorApplication.update += closureCallback;
         }
     }
+
+    internal static class WebRequest
+    {
+        internal static void Get(string url, Dictionary<string, string> headers = null, Action<float> onProgress = null, Action<string> onSuccess = null, Action<string> onError = null)
+        {
+            GetCoroutine(url, headers, onProgress, onSuccess, onError).StartEditorCoroutine();
+        }
+
+        private static IEnumerator GetCoroutine(string url, Dictionary<string, string> headers = null, Action<float> onProgress = null, Action<string> onSuccess = null, Action<string> onError = null)
+        {
+            using (var request = UnityWebRequest.Get(url))
+            {
+                // Add headers to the request
+                if (headers != null)
+                {
+                    foreach (var header in headers)
+                    {
+                        request.SetRequestHeader(header.Key, header.Value);
+                    }
+                }
+    
+                // Send the request
+                request.timeout = 60;
+                yield return request.SendWebRequest();
+    
+                while (request.isDone == false)
+                {
+                    onProgress?.Invoke(request.downloadProgress);
+                    yield return null;
+                }
+    
+                // Check for errors
+    #pragma warning disable CS0618
+                if (request.isNetworkError || request.isHttpError)
+    #pragma warning restore CS0618
+                {
+                    Debug.LogError("Error: " + request.error);
+                    onError?.Invoke(request.error);
+                }
+                else
+                {
+                    // Process the response
+                    string responseText = request.downloadHandler.text;
+                    onSuccess?.Invoke(responseText);
+                }
+            }
+            
+        }
+    }
 }

package/Runtime/AmaGDK.AmaPassport.cs

@@ -336,6 +336,7 @@ namespace Amanotes.Core
             public static string IpAddress => User.amaPassport.device.ipAddress;
             public static string Country => User.amaPassport.device.country;
             public static string DeviceUniqueId => User.amaPassport.device.deviceUniqueId;
+            public static string AppsflyerId => User.amaPassport.device.appsflyerId;
 
             internal static void Init()
             {

package/Runtime/AmaGDK.Analytics.cs

@@ -301,7 +301,8 @@ namespace Amanotes.Core
             internal static void ProcessEventQueue()
             {
                 if (eventQueue.Count <= 0) return;
-                bool showAnalyticsLog = Config.common.showAnalyticsLog;
+                SDKConfig common = Config.common;
+                bool showAnalyticsLog = common.showAnalyticsLog;
                 sessionStat.ClearLastFrameEventInfo();
 
                 while (eventQueue.Count > 0)
@@ -317,9 +318,11 @@ namespace Amanotes.Core
                     }
 
                     string eventNameToSend = GetEventNameToSend(eventData.eventName, countInSession, totalCount);
-                    if (Config.common.normalizeEventName) NormalizeEventName(ref eventNameToSend);
+                    if (common.normalizeEventName) NormalizeEventName(ref eventNameToSend);
 
-					if (showAnalyticsLog) Debug.Log($"AmaGDK | Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventData.parameters, true)}");
+                    if (showAnalyticsLog) Debug.Log($"AmaGDK | Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventData.parameters, true)}");
+                    
+                    common.quality.CheckEventQuality(eventData.eventName, eventData.parameters);
 
                     var inUseAdapterIDs = new List<string>();
                     foreach (AdapterContext m in listAdapters)
@@ -731,12 +734,28 @@ namespace Amanotes.Core
 
 namespace Amanotes.Core.Internal
 {
+    [Serializable]
+    public class AnalyticQualityConfig
+    {
+        public bool enable = false;
+        public AnalyticQualityAsset qualityAsset;
+        
+        public void CheckEventQuality(string eventName, Dictionary<string, object> parameters)
+        {
+            if (enable && qualityAsset != null)
+            {
+                qualityAsset.CheckEventQuality(eventName, parameters);
+            }
+        }
+    }
+
     public partial class SDKConfig
     {
         public bool showAnalyticsLog = true;
         public bool normalizeEventName = true;
         public bool checkMigrationIntegrity = true;
         public bool enableEventStat;
+        public AnalyticQualityConfig quality;
     }
 
     public interface IAnalyticAdapter