com.taptap.sdk.core 4.3.0-aplha.5

package/Standalone/Runtime/Internal/DeviceInfo.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Globalization;
+using System.Diagnostics;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net.NetworkInformation;
+using UnityEngine;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class DeviceInfo {
+
+#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
+        [DllImport("TapDBDeviceInfo", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr GetDeviceLanguage();
+#endif
+
+        public static string GetLanguage() {
+#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
+            return Marshal.PtrToStringAnsi(GetDeviceLanguage());
+#else
+            return CultureInfo.CurrentUICulture.IetfLanguageTag;
+#endif
+        }
+
+#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
+        [DllImport("kernel32.dll")]
+        static extern IntPtr GetCurrentProcess();
+
+        [DllImport("kernel32.dll")]
+        static extern uint GetProcessTimes(IntPtr processHandle,
+            out long creationTime,
+            out long exitTime,
+            out long kernelTime,
+            out long userTime);
+
+        static DateTime GetProcessStartTime()
+        {
+            IntPtr processHandle = GetCurrentProcess();
+            long creationTime;
+            GetProcessTimes(processHandle,
+                out creationTime,
+                out _,
+                out _,
+                out _);
+
+            return DateTime.FromFileTime(creationTime);
+        }
+#endif
+
+        //安全组提供的设备识别 ID 算法，用于后续数据串联
+        public static string GetLaunchUniqueID() 
+        {
+#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
+          // 获取当前进程对象
+          Process currentProcess = Process.GetCurrentProcess();
+          // 获取进程启动时间
+          DateTime startTime = GetProcessStartTime();
+          return toMd5(startTime.ToFileTime().ToString() + "-" + currentProcess.Id.ToString());
+#else
+          return "";
+#endif
+
+        }
+
+        public static void GetMacAddress(out string macAddressList, out string firstMacAddress)
+        {
+          List<string> mac_addrs = new List<string>();
+
+          try
+          {
+            NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();
+            foreach (NetworkInterface adapter in nics)
+            {
+              string physicalAddress = adapter.GetPhysicalAddress().ToString();
+              if (string.IsNullOrEmpty(physicalAddress))
+                continue;
+
+              physicalAddress = $"\"{physicalAddress}\"";
+              if (mac_addrs.IndexOf(physicalAddress) == -1)
+                mac_addrs.Add(physicalAddress);
+            }
+            // sort
+            mac_addrs.Sort();
+          }
+          catch (Exception e)
+          {
+            UnityEngine.Debug.Log("GetMacAddress Exception " + e.Message);
+          }
+          macAddressList = $"[{string.Join(",", mac_addrs)}]";
+          firstMacAddress = mac_addrs.Count > 0 ? mac_addrs[0].Replace("\"", "") : string.Empty;
+        }
+
+        private static string toMd5(string data)
+        {
+          byte[] buffer = System.Text.Encoding.Default.GetBytes(data);
+          try
+          {
+            System.Security.Cryptography.MD5CryptoServiceProvider chk = new System.Security.Cryptography.MD5CryptoServiceProvider();
+            byte[] some = chk.ComputeHash(buffer);
+            string ret = "";
+            foreach(byte a in some)
+            {
+                if (a < 16)
+                    ret += "0" + a.ToString("X");
+                else
+                    ret += a.ToString("X");                    
+            }
+            return ret.ToLower();
+          }
+          catch
+          {
+              throw;
+            }
+        }
+
+        public static string RAM
+        {
+          get {
+            return (SystemInfo.systemMemorySize * 1024L * 1024L).ToString();
+          }
+        }
+        
+        // 获取系统的 ROM 存储容量，单位为 Byte
+        public static string ROM
+        {
+          get {
+            string path = Application.persistentDataPath;
+            if (string.IsNullOrEmpty(path))
+              return "0";
+
+            try
+            {
+              System.IO.DriveInfo drive = new System.IO.DriveInfo(path);
+              return drive.TotalSize.ToString();
+            }
+            catch (Exception e)
+            {
+              UnityEngine.Debug.Log("GetROMInByte Exception " + e.Message);
+              return "0";
+            }
+          }
+        }
+      
+        public static string Local
+        {
+          get {
+            return CultureInfo.CurrentCulture.Name.Replace('-', '_');
+          }
+        }
+    }
+}

package/Standalone/Runtime/Internal/DeviceInfo.cs.meta

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

package/Standalone/Runtime/Internal/EventSender.cs

@@ -0,0 +1,239 @@
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class EventSender : MonoBehaviour
+    {
+        private const string EventFilePath = "events.json";
+        private string persistentDataPath = Application.persistentDataPath;
+        
+        private Queue<Dictionary<string, object>> eventQueue = new Queue<Dictionary<string, object>>();
+        private HttpClient httpClient;
+        private const int MaxEvents = 50;
+        private const int MaxBatchSize = 200;
+        private const float SendInterval = 15f;
+        private Timer timer;
+        private DateTime lastSendTime;
+
+        private int QueueCount => eventQueue.Count;
+
+        public EventSender()
+        {
+            // 设置计时器
+            timer = new Timer(OnTimerElapsed, null, TimeSpan.Zero, TimeSpan.FromSeconds(SendInterval));
+            lastSendTime = DateTime.Now;
+
+            // 初始化 HttpClient
+            var header = new Dictionary<string, string>
+            {
+                { "User-Agent", $"{TapTapSDK.SDKPlatform}/{TapTapSDK.SDKVersion}" }
+            };
+
+            var coreOptions = TapCoreStandalone.coreOptions;
+            if(coreOptions.region == TapTapRegionType.CN) {
+                HttpClientConfig config = new HttpClientConfig(Constants.SERVER_URL_BJ, header);
+                httpClient = new HttpClient(config);
+            } else {
+                HttpClientConfig config = new HttpClientConfig(Constants.SERVER_URL_SG, header);
+                httpClient = new HttpClient(config);
+            }
+
+            // 加载未发送的事件
+            LoadEvents();
+            SendEventsAsync(null);
+        }
+
+        public async void SendEventsAsync(Action onSendComplete)
+        {
+            if (eventQueue.Count == 0)
+            {
+                onSendComplete?.Invoke();
+                return;
+            }
+
+            var  eventsToSend = new List<Dictionary<string, object>>();
+            for (int i = 0; i < MaxBatchSize && eventQueue.Count > 0; i++)
+            {
+                eventsToSend.Add(eventQueue.Dequeue());
+            }
+
+            var body = new Dictionary<string, object> {
+                { "data", eventsToSend }
+            };
+
+            var resonse = await httpClient.Post("batch", body);
+            
+            // 判断是否请求成功
+            if (resonse == null)
+            {
+                // 将事件重新添加到队列
+                foreach (var eventParams in eventsToSend)
+                {
+                    eventQueue.Enqueue(eventParams);
+                }
+            }
+            else
+            {
+                Debug.Log("Events sent successfully");
+            }
+            onSendComplete?.Invoke();
+            SaveEvents();
+        }
+
+        public void Send(Dictionary<string, object> eventParams)
+        {
+            // 将事件添加到队列
+            eventQueue.Enqueue(eventParams);
+            SaveEvents();
+
+            // 检查队列大小
+            if (QueueCount >= MaxEvents)
+            {
+                SendEvents();
+                ResetTimer();
+            }
+        }
+
+        private void OnTimerElapsed(object state)
+        {
+            var offset = (DateTime.Now - lastSendTime).TotalSeconds;
+            if (offset >= SendInterval)
+            {
+                SendEvents();
+                ResetTimer();
+            }
+        }
+
+
+        private void ResetTimer()
+        {
+            timer.Change(TimeSpan.FromSeconds(SendInterval), TimeSpan.FromSeconds(SendInterval));
+        }
+
+        private void LoadEvents()
+        {
+            string filePath = Path.Combine(persistentDataPath, EventFilePath);
+            if (File.Exists(filePath))
+            {
+                string jsonData = File.ReadAllText(filePath);
+                if (string.IsNullOrEmpty(jsonData))
+                {
+                    return;
+                }
+                
+                var savedEvents = ConvertToListOfDictionaries(Json.Deserialize(jsonData));
+                if (savedEvents == null)
+                {
+                    return;
+                }
+                foreach (var eventParams in savedEvents)
+                {
+                    eventQueue.Enqueue(eventParams);
+                }
+            }
+        }
+
+        private void SaveEvents()
+        {
+            try
+            {
+                if (eventQueue == null)
+                {
+                    return;
+                }
+
+                var eventList = eventQueue.ToList();
+                string jsonData = Json.Serialize(eventList);
+
+                if (string.IsNullOrEmpty(EventFilePath))
+                {
+                    Debug.LogError("EventFilePath is null or empty");
+                    return;
+                }
+
+                string filePath = Path.Combine(persistentDataPath, EventFilePath);
+
+                if (string.IsNullOrEmpty(filePath))
+                {
+                    return;
+                }
+
+                File.WriteAllText(filePath, jsonData);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError("SaveEvents Exception - " + ex.Message);
+            }
+        }
+
+        public void SendEvents()
+        {
+            SendEventsAsync(() => lastSendTime = DateTime.Now);
+        }
+
+        private Dictionary<string, object> ConvertToDictionary(Dictionary<string, object> original)
+        {
+            var result = new Dictionary<string, object>();
+            foreach (var keyValuePair in original)
+            {
+                if (keyValuePair.Value is Dictionary<string, object> nestedDictionary)
+                {
+                    result[keyValuePair.Key] = ConvertToDictionary(nestedDictionary);
+                }
+                else if (keyValuePair.Value is List<object> nestedList)
+                {
+                    result[keyValuePair.Key] = ConvertToListOfDictionaries(nestedList);
+                }
+                else
+                {
+                    result[keyValuePair.Key] = keyValuePair.Value;
+                }
+            }
+            return result;
+        }
+        private List<Dictionary<string, object>> ConvertToListOfDictionaries(object deserializedData)
+        {
+            if (deserializedData is List<object> list)
+            {
+                var result = new List<Dictionary<string, object>>();
+                foreach (var item in list)
+                {
+                    if (item is Dictionary<string, object> dictionary)
+                    {
+                        result.Add(ConvertToDictionary(dictionary));
+                    }
+                    else
+                    {
+                        return null; // 数据格式不匹配
+                    }
+                }
+                return result;
+            }
+            return null; // 数据格式不匹配
+        }
+
+        [Serializable]
+        private class Serialization<T>
+        {
+            public List<T> items;
+            public Serialization(List<T> items)
+            {
+                this.items = items;
+            }
+
+            public List<T> ToList()
+            {
+                return items;
+            }
+        }
+    }
+}

package/Standalone/Runtime/Internal/EventSender.cs.meta

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

package/Standalone/Runtime/Internal/Http/HttpClient.cs

@@ -0,0 +1,211 @@
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Linq;
+using UnityEngine;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace TapSDK.Core.Standalone.Internal {
+    // 网络请求类，使用示例
+    /*
+    HttpClientConfig config = new HttpClientConfig("https://api.example.com");
+    config.DefaultHeaders.Add("Authorization", "Bearer your_token");
+
+    HttpClient client = new HttpClient(config);
+
+    // GET request
+    Dictionary<string, string> queryParams = new Dictionary<string, string>
+    {
+        { "query1", "value1" },
+        { "query2", "value2" }
+    };
+    string getResponse = await client.GetAsync("/path/to/resource", queryParams);
+    UnityEngine.Debug.Log("GET Response: " + getResponse);
+
+    // POST request
+    string postBody = "{\"key\":\"value\"}";
+    Dictionary<string, string> postHeaders = new Dictionary<string, string>
+    {
+        { "Content-Type", "application/json" }
+    };
+    string postResponse = await client.PostAsync("/path/to/resource", postBody, null, postHeaders);
+    UnityEngine.Debug.Log("POST Response: " + postResponse);
+    */
+    public class HttpClientConfig {
+        public string Host;
+        public Dictionary<string, string> DefaultHeaders;
+        public bool needSign = false;
+
+        public HttpClientConfig(string host, Dictionary<string, string> defaultHeaders = null, bool needSign = false) {
+            Host = host;
+            if (defaultHeaders == null) {
+                DefaultHeaders = new Dictionary<string, string>();
+            } else {
+                DefaultHeaders = defaultHeaders;
+            }
+            this.needSign = needSign;
+        }
+    }
+
+    public class HttpClient {
+        private readonly HttpClientConfig Config;
+        private static readonly System.Net.Http.HttpClientHandler handler = new System.Net.Http.HttpClientHandler
+        {
+            Proxy = new WebProxy(GetProxyAddress(), true), // Charles 代理地址
+            UseProxy = ShouldUseProxy()
+        };
+        private static readonly System.Net.Http.HttpClient client = new System.Net.Http.HttpClient(handler);
+
+        private static bool ShouldUseProxy()
+        {
+            string useProxyEnv = Environment.GetEnvironmentVariable("TAPSDK_USE_PROXY");
+            return !string.IsNullOrEmpty(useProxyEnv) && useProxyEnv.Equals("true", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string GetProxyAddress()
+        {
+            // 获取代理地址，默认值为 "http://localhost:8888"
+            string proxyAddress = Environment.GetEnvironmentVariable("TAPSDK_PROXY_ADDRESS");
+            return !string.IsNullOrEmpty(proxyAddress) ? proxyAddress : "http://localhost:8888";
+        }
+
+        public HttpClient(HttpClientConfig config)
+        {
+            this.Config = config;
+            foreach (var header in this.Config.DefaultHeaders)
+            {
+                client.DefaultRequestHeaders.Add(header.Key, header.Value);
+            }
+        }
+
+        public async Task<string> Get(string path, Dictionary<string, string> queryParameters = null, Dictionary<string, string> headers = null)
+        {
+            string url = BuildUrl(path, queryParameters);
+            var request = new HttpRequestMessage(HttpMethod.Get, url);
+
+            AddHeaders(request, headers);
+
+            return await SendRequest(request);
+        }
+
+        public async Task<string> Post(string path, Dictionary<string, object> body, Dictionary<string, string> queryParameters = null, Dictionary<string, string> headers = null)
+        {
+            string url = BuildUrl(path, queryParameters);
+            var request = new HttpRequestMessage(HttpMethod.Post, url);
+
+            AddHeaders(request, headers);
+
+            if (body != null)
+            {
+                string jsonBody = Json.Serialize(body);
+                StringContent requestContent = new StringContent(jsonBody);
+                requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+                request.Content = requestContent;
+            }
+
+            return await SendRequest(request);
+        }
+
+        private void AddHeaders(HttpRequestMessage request, Dictionary<string, string> headers)
+        {
+            // Add request-specific headers
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                {
+                    request.Headers.Add(header.Key, header.Value);
+                }
+            }
+        }
+
+        public static async Task<string> Sign(HttpRequestMessage req, string secret)
+        {
+            string methodPart = req.Method.Method;
+            string urlPathAndQueryPart = req.RequestUri.PathAndQuery;
+
+            string headersPart = GetHeadersPart(req.Headers);
+
+            string bodyPart = string.Empty;
+            if (req.Content != null)
+            {
+                bodyPart = await req.Content.ReadAsStringAsync();
+            }
+
+            string signParts = methodPart + "\n" + urlPathAndQueryPart + "\n" + headersPart + "\n" + bodyPart + "\n";
+
+            using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret)))
+            {
+                byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(signParts));
+                return Convert.ToBase64String(hash);
+            }
+        }
+
+        private static string GetHeadersPart(HttpRequestHeaders headers)
+        {
+            var headerKeys = headers
+                .Where(h => h.Key.StartsWith("x-tap-", StringComparison.OrdinalIgnoreCase))
+                .OrderBy(h => h.Key.ToLowerInvariant())
+                .Select(h => $"{h.Key.ToLowerInvariant()}:{string.Join(",", h.Value)}")
+                .ToList();
+
+            return string.Join("\n", headerKeys);
+        }
+        private async Task<string> SendRequest(HttpRequestMessage request)
+        {
+            if (this.Config.needSign)
+            {
+                string sign = await Sign(request, TapCoreStandalone.coreOptions.clientToken);
+                request.Headers.Add("X-Tap-Sign", sign);
+            }
+
+            HttpResponseMessage response;
+
+            try
+            {
+                response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+                request.Dispose();
+            }
+            catch (HttpRequestException e)
+            {
+                Debug.Log($"Request error: {e}");
+                return null;
+            }
+
+            string responseBody = await response.Content.ReadAsStringAsync();
+            var responseJson = Json.Deserialize(responseBody) as Dictionary<string, object>;
+            if (responseJson != null)
+            {
+                int now = (int)Convert.ToInt64(responseJson["now"]);
+                if (now > 0)
+                {
+                    TimeUtil.FixTime(now);
+                }
+            }
+
+            Debug.Log($"Response Code: {response.StatusCode}, Body: {responseBody}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                Debug.Log($"Error: {response}");
+                return null;
+            }
+
+            response.Dispose();
+            return responseBody;
+        }
+
+        private string BuildUrl(string path, Dictionary<string, string> queryParameters) {
+            string url = $"{this.Config.Host}/{path}";
+            if (queryParameters != null) {
+                IEnumerable<string> queryPairs = queryParameters.Select(kv => $"{kv.Key}={Uri.EscapeDataString(kv.Value.ToString())}");
+                string queries = string.Join("&", queryPairs);
+                url = $"{url}?{queries}";
+            }
+            return url;
+        }
+    }
+}

package/Standalone/Runtime/Internal/Http/HttpClient.cs.meta

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

package/Standalone/Runtime/Internal/Http/NetUtils.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using UnityEditor;
+using UnityEngine;
+
+namespace TapSDK.Core.Standalone.Internal
+{
+    public class NetUtils
+    {
+        // 随机生成一个 10 位的字符串
+        public static string GenerateNonce()
+        {
+            string chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+            char[] nonce = new char[10];
+            for (int i = 0; i < 10; i++)
+            {
+                nonce[i] = chars[UnityEngine.Random.Range(0, chars.Length)];
+            }
+            return new string(nonce);
+        }
+
+        public static Dictionary<string, string> commonHeaders {
+            get {
+                var headers = new Dictionary<string, string> {
+                    { "User-Agent", $"{TapTapSDK.SDKPlatform}/{TapTapSDK.SDKVersion}" },
+                    { "X-Tap-Ts", TimeUtil.GetCurrentTime().ToString() },
+                    { "X-Tap-Nonce", NetUtils.GenerateNonce() },
+                    { "X-Tap-PN", "TapSDK" },
+                    { "X-Tap-Lang", Tracker.getServerLanguage() },
+                    { "X-Tap-Device-Id", Identity.DeviceId },
+                    { "X-Tap-Platform", "PC" },
+                    { "X-Tap-SDK-Module", "TapSDKCore" },
+                    { "X-Tap-SDK-Module-Version", TapTapSDK.SDKVersion },
+                    { "X-Tap-SDK-Artifact", "Unity" }
+                };
+                
+                if (TapCoreStandalone.User.Id != null) {
+                    headers.Add("X-Tap-SDK-Game-User-Id", TapCoreStandalone.User.Id);
+                }
+
+                return headers;
+            }
+        }
+    }
+}

package/Standalone/Runtime/Internal/Http/NetUtils.cs.meta

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