v.0.1.0 (#2)

* user verification tracking

* Refactor flow

* Update readme

* Missing file

* Correct AnalyticConst namespace

---------

Co-authored-by: bac.tran <[email protected]>

Author: phuong-axie

Assets/Scenes.meta Assets/AxieInfinity.meta

@@ -0,0 +1,14 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Analytic
+{
+    public class AnalyticBehavior : MonoBehaviour
+    {
+        private void Awake()
+        {
+            DontDestroyOnLoad(this);
+        }
+    }
+}

Assets/Scripts.meta Assets/AxieInfinity/Analytic.meta

@@ -19,7 +19,7 @@ static void OnCheckInput()
 #endif
             if (isPressed)
             {
-                heartbeatStats.OnNewPressed();
+                _heartbeatStats.OnNewPressed();
             }
         }
     }

Assets/Scripts/Analytic.meta Assets/AxieInfinity/Analytic/Core.meta

@@ -15,17 +15,18 @@ public partial class AnalyticManager
         public const int REQUEST_INTERVAL = 10;
         public const int RETRY_NUMBER = 3;
         public const int EVENT_PER_REQUEST = 300;
-        public static string endPoint = "https://x.skymavis.com/track";
-        public static string apiKey;
-        public static HeartbeatStats heartbeatStats;
+        public static readonly string EN_POINT = "https://x.skymavis.com/track";
+        public static string API_KEY;
+        private static HeartbeatStats _heartbeatStats;
+        private static string _currentName = "";
 
         private static readonly Dictionary<AnalyticRequest, int> dictRetryRequests = new Dictionary<AnalyticRequest, int>();
 
         private static IEnumerator CheckingTimer()
         {
             while (true)
             {
-                if (initialized)
+                if (initialized && !string.IsNullOrEmpty(userId) && !string.IsNullOrEmpty(API_KEY))
                 {
                     if (Time.realtimeSinceStartup - lastRequestTime > REQUEST_INTERVAL)
                     {
@@ -44,15 +45,25 @@ private static void CheckSendAnalyticRequest()
             if (analyticListData == null) return;
             if(analyticListData.listEventDatas.Count == 0)
             {
-                string heartbeatData = JsonConvert.SerializeObject(heartbeatStats);
+                //string heartbeatData = JsonConvert.SerializeObject(_heartbeatStats);
 
-                var jObject = new JObject();
-                var jHeartbeatData = JObject.Parse(heartbeatData);
-                jObject.Add("action_properties", jHeartbeatData);
-                jObject.Add(new JProperty("event", "heartbeat"));
-                AddEvent(EventTypes.Track, jObject);
+                //var jObject = new JObject();
+                //var jHeartbeatData = JObject.Parse(heartbeatData);
+                //jObject.Add("action_properties", jHeartbeatData);
+                //jObject.Add(new JProperty("event", "heartbeat"));
+                AddEvent(EventTypes.Track, new
+                {
+                    @event = "heartbeat",
+                    action_properties = _heartbeatStats
+                });
+                _heartbeatStats.EndBeat();
+            }
 
-                heartbeatStats.EndBeat();
+            var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+            if (activeScene != null && activeScene.name != _currentName)
+            {
+                _currentName = activeScene.name;
+                AnalyticManager.AddEvent(EventTypes.Screen, new { @event = "s_" + _currentName });
             }
 
             //Create new request
@@ -61,15 +72,15 @@ private static void CheckSendAnalyticRequest()
 
         private static void Submit(AnalyticRequest data, Action<AsyncOperation> cb)
         {
-            var request = new UnityWebRequest(endPoint, "POST"); // start as POST, then change later
+            var request = new UnityWebRequest(EN_POINT, "POST"); // start as POST, then change later
             request.SetRequestHeader("Content-Type", "application/json");
 
-            var apiBytes = Encoding.UTF8.GetBytes($"{apiKey}:");
+            var apiBytes = Encoding.UTF8.GetBytes($"{API_KEY}:");
             string encodedText = Convert.ToBase64String(apiBytes, Base64FormattingOptions.None);
             request.SetRequestHeader("Authorization", "Basic " + encodedText);
             request.downloadHandler = new DownloadHandlerBuffer();
             var json = JsonConvert.SerializeObject(data, AnalyticListData.SerializerSettings);
-            Debug.Log($"[Analytic]: {json}");
+            Debug.Log(json);
             var jsonBytes = new UTF8Encoding().GetBytes(json);
             request.uploadHandler = new UploadHandlerRaw(jsonBytes);
 
@@ -95,7 +106,6 @@ private static void Submit(AnalyticRequest data, Action<AsyncOperation> cb)
 
         private static IEnumerator RequestAfter(AnalyticRequest analyticRequest, float seconds)
         {
-           
             yield return new WaitForSeconds(seconds);
             DoRequest(analyticRequest);
         }
@@ -165,7 +175,7 @@ static void Finish(AnalyticRequest request)
             }
 
             analyticListData.SaveToDevice();
-            Debug.Log($"[Analytic] Request Finish: {request.events.Count}");
+            //Debug.Log($"[Analytic] Request Finish: {request.events.Count}");
         }
     }
 }

Assets/AxieInfinity/Analytic/Core/AnalyticBehavior.cs

@@ -0,0 +1,181 @@
+using System;
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace Analytic
+{
+    public partial class AnalyticManager
+    {
+        public static string buildVersion => $"{Application.version}";
+       
+        public static string sessionId { get; private set; }
+        public static long sessionOffset { get; private set; }
+        public static bool initialized { get; private set; }
+        public static string userId;
+        public static string env;
+        
+        private static float lastRequestTime;
+
+        private static AnalyticListData analyticListData = new AnalyticListData(AnalyticListData.analyticListData);
+        public static AnalyticBehavior analyticBehavior;
+     
+        public static void IdentifyLocalUser()
+        {
+            JObject jObject = LoadLocalProfile();
+
+            UserVertification.GetArgVertification(out var signature, out var message);
+            var userData = UserVertification.Vertification(signature, message);
+            if(userData != null)
+            {
+                string roninAddress = (string)userData["roninAddress"];
+                if (string.IsNullOrEmpty(roninAddress))
+                {
+                    jObject.Add(new JProperty("ronin_address", roninAddress));
+                }
+            }
+            AnalyticManager.AddEvent(EventTypes.Identify, jObject);
+        }
+
+        public static void IdentifyCustomUser(JObject userProperties)
+        {
+            JObject jObject = LoadLocalProfile();
+
+            UserVertification.GetArgVertification(out var signature, out var message);
+            var userData = UserVertification.Vertification(signature, message);
+            if (userData != null)
+            {
+                string roninAddress = (string)userData["roninAddress"];
+                if (string.IsNullOrEmpty(roninAddress))
+                {
+                    jObject.Add(new JProperty("ronin_address", roninAddress));
+                }
+            }
+
+            if(userProperties != null)
+            {
+                string roninAddress = (string)userData["ronin_address"];
+                if (!string.IsNullOrEmpty(roninAddress))
+                {
+                    jObject["ronin_address"] = roninAddress;
+                }
+                string userId = (string)userProperties["user_id"];
+                if (!string.IsNullOrEmpty(userId))
+                {
+                    AnalyticManager.userId = userId;
+                }
+                jObject.Add(new JProperty("user_properties", userProperties));
+            }
+
+            StartNewSession(AnalyticManager.userId);
+            AnalyticManager.AddEvent(EventTypes.Identify, jObject);
+        }
+
+        private static JObject LoadLocalProfile()
+        {
+            string userId = PlayerPrefs.GetString("userId");
+            if (string.IsNullOrEmpty(userId))
+            {
+                userId = System.Guid.NewGuid().ToString();
+                PlayerPrefs.SetString("userId", userId);
+            }
+            AnalyticManager.userId = userId;
+#if UNITY_EDITOR
+            AnalyticManager.env = "dev";
+#else
+            AnalyticManager.env = "staging";
+#endif
+
+            var jObject = new JObject();
+            jObject.Add(new JProperty("device_name", SystemInfo.deviceModel));
+            jObject.Add(new JProperty("device_id", SystemInfo.deviceUniqueIdentifier));
+            jObject.Add(new JProperty("platform_name", Application.platform.ToString()));
+            jObject.Add(new JProperty("platform_version", SystemInfo.operatingSystem));
+
+            jObject.Add(new JProperty("system_memory_size", SystemInfo.systemMemorySize));
+            jObject.Add(new JProperty("processor_count", SystemInfo.processorCount));
+            jObject.Add(new JProperty("graphics_device", SystemInfo.graphicsDeviceName));
+            jObject.Add(new JProperty("graphics_memory_size", SystemInfo.graphicsMemorySize));
+            return jObject;
+        }
+
+        public static void InitManager(string apiKey)
+        {
+            AnalyticManager.API_KEY = apiKey;
+            if (initialized) return;
+            if (string.IsNullOrEmpty(EN_POINT) || string.IsNullOrEmpty(apiKey))
+            {
+                Debug.LogError("AnalyticManager invalid endpoint");
+                return;
+            }
+            analyticListData = AnalyticListData.LoadFromDevice();
+            sessionId = Guid.NewGuid().ToString();
+            sessionOffset = 1;
+
+            AnalyticManager._heartbeatStats = new HeartbeatStats();
+            AnalyticManager._heartbeatStats.Init();
+
+            lastRequestTime = float.MinValue;
+            initialized = true;
+
+            var behavior = new GameObject();
+            behavior.name = "AnalyticBehavior";
+            analyticBehavior = behavior.AddComponent<AnalyticBehavior>();
+            UnityEngine.GameObject.DontDestroyOnLoad(behavior);
+
+            analyticBehavior.StartCoroutine(CheckingTimer());
+            Debug.Log("AnalyticManager StartSession");
+        }
+
+        private static void StartNewSession(string userId)
+        {
+            if (userId != PlayerPrefs.GetString("userId"))
+            {
+                PlayerPrefs.SetString("userId", userId);
+                sessionId = Guid.NewGuid().ToString();
+                sessionOffset = 1;
+
+                AnalyticManager._heartbeatStats = new HeartbeatStats();
+                AnalyticManager._heartbeatStats.Init();
+            }
+        }
+
+        public static void AddEvent(EventTypes type, object data)
+        {
+            var analyticEvent = new AnalyticEvent(type, data);
+            AddEvent(analyticEvent);
+        }
+
+        private static void AddEvent(AnalyticEvent analyticEvent)
+        {
+            if (!initialized) return;
+            analyticEvent.MergeData(GetCommonFields());
+            analyticListData.listEventDatas.Add(analyticEvent);
+            analyticListData.SaveToDevice();
+        }
+
+        private static object GetCommonFields()
+        {
+            var internetType = "unknown";
+            if (Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork)
+            {
+                internetType = "wifi_or_cable";
+            }
+            else if (Application.internetReachability == NetworkReachability.ReachableViaCarrierDataNetwork)
+            {
+                internetType = "data_network";
+            }
+
+            return new
+            {
+                
+                uuid = Guid.NewGuid().ToString(),
+                timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"),
+                session_id = sessionId,
+                offset = sessionOffset++,
+                user_id = userId,
+                build_version = env + ":" + buildVersion,
+                internet_type = internetType,
+            };
+        }
+    }
+}

Assets/Scripts/Analytic/AnalyticBehavior.cs.meta Assets/AxieInfinity/Analytic/Core/AnalyticBehavior.cs.meta

@@ -0,0 +1,68 @@
+using System;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+
+namespace Analytic
+{
+    public class UserVertification
+    {
+        public static string GetArg(string name)
+        {
+            var args = System.Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i] == name && args.Length > i + 1)
+                {
+                    return args[i + 1];
+                }
+            }
+            return string.Empty;
+        }
+
+        public static void GetArgVertification(out string signature, out string message)
+        {
+            signature = GetArg("-signature");
+            message = GetArg("-message");
+        }
+
+        private static byte[] StringToByteArray(string hex)
+        {
+            return Enumerable.Range(0, hex.Length)
+                             .Where(x => x % 2 == 0)
+                             .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
+                             .ToArray();
+        }
+
+        public static JObject Vertification(string signature, string message)
+        {
+            if (string.IsNullOrEmpty(message)) return null;
+
+            var messageData = StringToByteArray(message);
+            var messageStr = System.Text.Encoding.UTF8.GetString(messageData);
+            //var signatureData = StringToByteArray(signature);
+            try
+            {
+                //This not support on dotnet20, so just skip verify at client side
+                // var rsa = RSA.Create();
+                // rsa.ImportRSAPublicKey(DecodeOpenSSLPublicKey(rsaPub), out var bytesRead);
+                // UnityEngine.Debug.Log($"bytesRead: ${bytesRead}");
+
+                JObject userData = (JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(messageStr);
+                if (userData != null)
+                {
+                    UnityEngine.Debug.Log($"MH user data: {Newtonsoft.Json.JsonConvert.SerializeObject(userData)}");
+                    return userData;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            catch (System.Exception ex)
+            {
+                UnityEngine.Debug.LogError(ex);
+                return null;
+            }
+        }
+    }
+}