com.xd.sdk.tap 0.0.6-xd.1

package/Core/Standalone/Runtime/Internal/Http/TapHttpSign.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace TapSDK.Core.Standalone.Internal.Http
+{
+
+    /// <summary>
+    /// 定义 HTTP 签名相关操作的接口。
+    /// </summary>
+    public interface ITapHttpSign
+    {
+        /// <summary>
+        /// 获取固定的 HTTP 请求头信息。
+        /// </summary>
+        /// <returns>返回包含固定请求头的字典。</returns>
+        Dictionary<string, string> GetFixedHeaders(string url, HttpMethod method, string moduleName, string moduleVersion, bool enableAuthorization);
+
+        /// <summary>
+        /// 获取固定的查询参数。
+        /// </summary>
+        /// <returns>返回包含固定查询参数的字典。</returns>
+        Dictionary<string, string> GetFixedQueryParams();
+
+        /// <summary>
+        /// 对 HTTP 请求数据进行签名处理。
+        /// </summary>
+        /// <param name="signData">包含请求数据的 <see cref="TapHttpSignData"/> 对象。</param>
+        void Sign(HttpRequestMessage signData);
+    }
+
+    public class TapHttpSign
+    {
+        public static ITapHttpSign CreateDefaultSign()
+        {
+            return new Default();
+        }
+
+        public static ITapHttpSign CreateNoneSign()
+        {
+            return new None();
+        }
+
+        private class Default : ITapHttpSign
+        {
+            public Dictionary<string, string> GetFixedHeaders(string url, HttpMethod method, string moduleName, string moduleVersion, bool enableAuthorization)
+            {
+                _ = method ?? throw new ArgumentNullException(nameof(method));
+                _ = moduleName ?? throw new ArgumentNullException(nameof(moduleName));
+                _ = moduleVersion ?? throw new ArgumentNullException(nameof(moduleVersion));
+
+                if (method == HttpMethod.Post || method == HttpMethod.Get)
+                {
+                    Dictionary<string, string> headers = new Dictionary<string, string>
+                    {
+                        { "X-Tap-PN", "TapSDK" },
+                        { "X-Tap-Device-Id", TapHttpUtils.GenerateDeviceId()},
+                        { "X-Tap-Platform", "PC"},
+                        { "X-Tap-SDK-Module", moduleName},
+                        { "X-Tap-SDK-Module-Version", moduleVersion},
+                        { "X-Tap-SDK-Artifact", "Unity"},
+                        { "X-Tap-Ts", TapHttpUtils.GenerateTime()},
+                        { "X-Tap-Nonce", TapHttpUtils.GenerateNonce()},
+                        { "X-Tap-Lang", TapHttpUtils.GenerateLanguage()},
+                        { "User-Agent", TapHttpUtils.GenerateUserAgent()},
+                    };
+                    string currentUserId = TapCoreStandalone.User?.Id;
+                    if(currentUserId != null && currentUserId.Length > 0) {
+                        headers.Add("X-Tap-SDK-Game-User-Id", currentUserId);
+                    }
+                    if (enableAuthorization)
+                    {
+                        string authorization = TapHttpUtils.GenerateAuthorization(url, method.ToString());
+                        if (authorization != null)
+                        {
+                            headers.Add("Authorization", authorization);
+                        }
+                    }
+                    return headers;
+                }
+                return null;
+            }
+
+            public Dictionary<string, string> GetFixedQueryParams()
+            {
+                return new Dictionary<string, string>
+                {
+                    { "client_id", TapCoreStandalone.coreOptions.clientId }
+                };
+            }
+
+            public async void Sign(HttpRequestMessage requestMessage)
+            {
+                _ = requestMessage ?? throw new ArgumentNullException(nameof(requestMessage));
+
+                string clientToken = TapCoreStandalone.coreOptions.clientToken;
+                string methodPart = requestMessage.Method.Method;
+                string urlPathAndQueryPart = requestMessage.RequestUri.PathAndQuery;
+                var headerKeys = requestMessage.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();
+                string headersPart = string.Join("\n", headerKeys);
+                string bodyPart = string.Empty;
+                if (requestMessage.Content != null)
+                {
+                    bodyPart = await requestMessage.Content.ReadAsStringAsync();
+                }
+                string signParts = methodPart + "\n" + urlPathAndQueryPart + "\n" + headersPart + "\n" + bodyPart + "\n";
+                using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(clientToken)))
+                {
+                    byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(signParts));
+                    string sign = Convert.ToBase64String(hash);
+                    requestMessage.Headers.Add("X-Tap-Sign", sign);
+                }
+            }
+        }
+
+        private class None : ITapHttpSign
+        {
+            public Dictionary<string, string> GetFixedHeaders(string url, HttpMethod method, string moduleName, string moduleVersion, bool enableAuthorization)
+            {
+                return null;
+            }
+
+            public Dictionary<string, string> GetFixedQueryParams()
+            {
+                return null;
+            }
+
+            public void Sign(HttpRequestMessage signData)
+            {
+                // do nothing
+            }
+        }
+    }
+}

package/Core/Standalone/Runtime/Internal/Http/TapHttpSign.cs.meta

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

package/Core/Standalone/Runtime/Internal/Http/TapHttpUtils.cs

@@ -0,0 +1,196 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using TapSDK.Core.Internal.Log;
+using TapSDK.Core.Standalone.Internal.Service;
+using UnityEngine;
+
+namespace TapSDK.Core.Standalone.Internal.Http
+{
+    public static class TapHttpTime
+    {
+        private static int timeOffset = 0;
+        private static void SetTimeOffset(int offset)
+        {
+            timeOffset = offset;
+        }
+
+        // 获取当前时间的秒级时间戳
+        public static int GetCurrentTime()
+        {
+            DateTime epochStart = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+            TimeSpan timeSpan = DateTime.UtcNow - epochStart;
+            return (int)timeSpan.TotalSeconds + timeOffset;
+        }
+
+        public static void FixTime(int time)
+        {
+            if (time == 0)
+            {
+                return;
+            }
+            SetTimeOffset(time - (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds);
+        }
+
+
+        // 服务端同步的时间戳
+        private static long LastServerTime = 0;
+        // 设置服务端时间时，当前应用启动时间
+        private static long LastStartUpTime = 0 ;
+        internal static void ResetLastServerTime(long time){
+            LastServerTime = time;
+            LastStartUpTime =  (long) Time.realtimeSinceStartup;
+        }
+
+        /// <summary>
+        /// 根据服务端时间获取当前时间戳，单位：秒
+        /// </summary>
+        /// <returns>当前时间戳，当服务端时间未设置过时，返回值为 0</returns>
+        public static long GetCurrentServerTime(){
+            if(LastServerTime == 0){
+                return 0;
+            }
+            long startUpTime = (long) Time.realtimeSinceStartup;
+            return LastServerTime + startUpTime - LastStartUpTime;
+        }
+    }
+
+    public static class TapHttpUtils
+    {
+
+        private static readonly TapLog tapLog = new TapLog("Http");
+
+        internal 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 string GenerateUserAgent()
+        {
+            return $"TapSDK-Unity/{TapTapSDK.Version}";
+        }
+
+        internal static string GenerateTime()
+        {
+            return TapHttpTime.GetCurrentTime().ToString();
+        }
+
+        internal static string GenerateLanguage()
+        {
+            return Tracker.getServerLanguage();
+        }
+
+        internal static string GenerateDeviceId()
+        {
+            return SystemInfo.deviceUniqueIdentifier;
+        }
+
+        internal static string GenerateAuthorization(string url, string method)
+        {
+            Type interfaceType = typeof(ITapLoginService);
+            Type[] initTaskTypes = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(asssembly =>
+                {
+                    string fullName = asssembly.GetName().FullName;
+                    return fullName.StartsWith("TapSDK.Login.Standalone.Runtime");
+                })
+                .SelectMany(assembly => assembly.GetTypes())
+                .Where(clazz =>
+                {
+                    return interfaceType.IsAssignableFrom(clazz) && clazz.IsClass;
+                })
+                .ToArray();
+            if (initTaskTypes.Length != 1)
+            {
+                return null;
+            }
+            try
+            {
+                ITapLoginService tapLoginService = Activator.CreateInstance(initTaskTypes[0]) as ITapLoginService;
+                string authorization = tapLoginService.ObtainAuthorizationAsync(url, method);
+                return authorization;
+            }
+            catch (Exception e)
+            {
+                TapLog.Error("e = " + e);
+            }
+            return null;
+        }
+
+        public static void PrintRequest(HttpClient client, HttpRequestMessage request)
+        {
+            if (client == null)
+            {
+                return;
+            }
+            if (request == null)
+            {
+                return;
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("=== HTTP Request Start ===");
+            sb.AppendLine($"URL: {request.RequestUri}");
+            sb.AppendLine($"Method: {request.Method}");
+            sb.AppendLine($"Headers: ");
+            foreach (var header in client.DefaultRequestHeaders)
+            {
+                sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
+            }
+            foreach (var header in request.Headers)
+            {
+                sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
+            }
+            if (request.Content != null)
+            {
+                foreach (var header in request.Content.Headers)
+                {
+                    sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
+                }
+            }
+            string contentString = null;
+            try
+            {
+                contentString = request.Content.ReadAsStringAsync().Result;
+            }
+            catch (Exception)
+            {
+            }
+            if (!string.IsNullOrEmpty(contentString))
+            {
+                sb.AppendLine($"Content: \n{contentString}");
+            }
+            sb.AppendLine("=== HTTP Request End ===");
+            tapLog.Log($"HTTP Request [{request.RequestUri.PathAndQuery}]", sb.ToString());
+        }
+
+        public static void PrintResponse(HttpResponseMessage response)
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("=== HTTP Response Start ===");
+            sb.AppendLine($"URL: {response.RequestMessage.RequestUri}");
+            sb.AppendLine($"Status Code: {response.StatusCode}"); 
+            string contentString = null;
+            try
+            {
+                contentString = response.Content.ReadAsStringAsync().Result;
+            }
+            catch (Exception)
+            {
+            }
+            if (!string.IsNullOrEmpty(contentString))
+            {
+                sb.AppendLine($"Content: {contentString}");
+            }
+            sb.AppendLine("=== HTTP Response End ===");
+            tapLog.Log($"HTTP Response [{response.RequestMessage.RequestUri.PathAndQuery}]", sb.ToString());
+        }
+
+    }
+}

package/Core/Standalone/Runtime/Internal/Http/TapHttpUtils.cs.meta

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

package/Core/Standalone/Runtime/Internal/Http.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 928b028f42aae4ded9b34d5c4c6536d1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Core/Standalone/Runtime/Internal/Identity.cs

@@ -0,0 +1,43 @@
+using System;
+using UnityEngine;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class Identity {
+        public static readonly string DEVICE_ID_KEY = "tapdb_unique_id";
+        public static readonly string PERSISTENT_ID_KEY = "tapdb_persist_id";
+        public static readonly string INSTALLATION_ID_KEY = "tapdb_install_id";
+
+        public static string DeviceId {
+            get {
+                string deviceId = TapCoreStandalone.Prefs.Get<string>(DEVICE_ID_KEY);
+                if (string.IsNullOrWhiteSpace(deviceId)) {
+                    deviceId = SystemInfo.deviceUniqueIdentifier;
+                    TapCoreStandalone.Prefs.Set(DEVICE_ID_KEY, deviceId);
+                }
+                return deviceId;
+            }
+        }
+
+        public static string PersistentId {
+            get {
+                string persistentId = TapCoreStandalone.Prefs.Get<string>(PERSISTENT_ID_KEY);
+                if (string.IsNullOrWhiteSpace(persistentId)) {
+                    persistentId = Guid.NewGuid().ToString();
+                    TapCoreStandalone.Prefs.Set(PERSISTENT_ID_KEY, persistentId);
+                }
+                return persistentId;
+            }
+        }
+
+        public static string InstallationId {
+            get {
+                string installationId = TapCoreStandalone.Prefs.Get<string>(INSTALLATION_ID_KEY);
+                if (string.IsNullOrWhiteSpace(installationId)) {
+                    installationId = Guid.NewGuid().ToString();
+                    TapCoreStandalone.Prefs.Set(INSTALLATION_ID_KEY, installationId);
+                }
+                return installationId;
+            }
+        }
+    }
+}

package/Core/Standalone/Runtime/Internal/Identity.cs.meta

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

package/Core/Standalone/Runtime/Internal/Openlog/TapAppDurationStandalone.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using TapSDK.Core.Internal.Log;
+
+namespace TapSDK.Core.Standalone.Internal.Openlog
+{
+    public class TapAppDurationStandalone
+    {
+        private const string MODULE_NAME = "app_duration";
+
+        private static readonly TapLog log = new TapLog("AppDuration");
+
+        public static void Enable()
+        {
+#if UNITY_STANDALONE
+            // log.Log("Enable");
+            List<string> modules = new List<string> { MODULE_NAME };
+            TapOpenlogWrapper.TdkEnableModules(JsonConvert.SerializeObject(modules));
+#endif
+        }
+
+        public static void Disable()
+        {
+#if UNITY_STANDALONE
+            // log.Log("Disable");
+            List<string> modules = new List<string> { MODULE_NAME };
+            TapOpenlogWrapper.TdkDisableModules(JsonConvert.SerializeObject(modules));
+#endif
+        }
+
+        public static void SetExtraAppDurationParams(Dictionary<string, string> param)
+        {
+#if UNITY_STANDALONE
+            log.Log("SetExtraAppDurationParams param: ", JsonConvert.SerializeObject(param));
+            if (param == null)
+            {
+                log.Warning("SetExtraAppDurationParams param is null");
+                return;
+            }
+            TapOpenlogWrapper.TdkSetExtraAppDurationParams(JsonConvert.SerializeObject(param));
+#endif
+        }
+
+        public static void OnLogin(string openId)
+        {
+#if UNITY_STANDALONE
+            log.Log("OnLogin openId: " + openId);
+            if (openId == null)
+            {
+                log.Warning("OnLogin openId is null");
+                return;
+            }
+            Dictionary<string, string> userInfo = new Dictionary<string, string>
+            {
+                {TapOpenlogParamConstants.PARAM_OPEN_ID, openId}
+            };
+            TapOpenlogWrapper.TdkOnLogin(JsonConvert.SerializeObject(userInfo));
+#endif
+        }
+
+        public static void OnLogout()
+        {
+#if UNITY_STANDALONE
+            log.Log("OnLogout");
+            TapOpenlogWrapper.TdkOnLogout();
+#endif
+        }
+
+        public static void OnForeground()
+        {
+#if UNITY_STANDALONE
+            log.Log("OnForeground");
+            TapOpenlogWrapper.TdkOnForeground();
+#endif
+        }
+
+        public static void OnBackground()
+        {
+#if UNITY_STANDALONE
+            log.Log("OnBackground");
+            TapOpenlogWrapper.TdkOnBackground();
+#endif
+        }
+
+        public static string Version()
+        {
+
+            string v = null;
+#if UNITY_STANDALONE
+            try
+            {
+                v = TapOpenlogWrapper.GetTdkVersion();
+            }
+            catch (Exception e)
+            {
+                log.Error("GetVersion error: " + e.Message);
+            }
+            log.Log("Version: " + v);
+#endif
+            return v;
+        }
+
+        public static string GitCommit()
+        {
+            string v = null;
+#if UNITY_STANDALONE
+            try
+            {
+                v = TapOpenlogWrapper.GetTdkGitCommit();
+            }
+            catch (Exception e)
+            {
+                log.Error("GitCommit error: " + e.Message);
+            }
+            log.Log("GitCommit: " + v);
+#endif
+            return v;
+        }
+    }
+}

package/Core/Standalone/Runtime/Internal/Openlog/TapAppDurationStandalone.cs.meta

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

package/Core/Standalone/Runtime/Internal/Openlog/TapCoreTracker.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace TapSDK.Core.Standalone.Internal.Openlog
+{
+    internal class TapCoreTracker
+    {
+
+        private const string ACTION_INIT = "init";
+        private const string ACTION_START = "start";
+        private const string ACTION_SUCCESS = "success";
+        private const string ACTION_FAIL = "fail";
+        private const string ACTION_CANCEL = "cancel";
+
+        internal static string SUCCESS_TYPE_RESTART = "restart";
+        internal static string SUCCESS_TYPE_INIT = "init";
+
+        internal static string METHOD_LAUNCHER = "isLaunchedFromTapTapPC";
+
+        private static TapCoreTracker instance;
+
+        private TapOpenlogStandalone openlog;
+
+        private TapCoreTracker()
+        {
+            openlog = new TapOpenlogStandalone("TapSDKCore", TapTapSDK.Version);
+        }
+
+        public static TapCoreTracker Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = new TapCoreTracker();
+                }
+                return instance;
+            }
+        }
+
+        internal void TrackInit()
+        {
+            ReportLog(ACTION_INIT);
+        }
+
+        internal void TrackStart(string funcNace, string seesionId)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+            };
+            ReportLog(ACTION_START, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackSuccess(string funcNace, string seesionId, string successType)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+                { "launch_success_type", successType }
+            };
+            ReportLog(ACTION_SUCCESS, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackCancel(string funcNace, string seesionId)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+            };
+            ReportLog(ACTION_CANCEL, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        internal void TrackFailure(string funcNace, string seesionId, int errorCode = -1, string errorMessage = null)
+        {
+            Dictionary<string, string> parameters = new Dictionary<string, string>
+            {
+                { "func_name", funcNace },
+                { "session_id", seesionId },
+                { "error_code", errorCode.ToString() },
+                { "error_msg", errorMessage }
+            };
+            ReportLog(ACTION_FAIL, new Dictionary<string, string>()
+            {
+                { "args", JsonConvert.SerializeObject(parameters) }
+            });
+        }
+
+        private void ReportLog(string action, Dictionary<string, string> parameters = null)
+        {
+            openlog.LogBusiness(action, parameters);
+        }
+    }
+}

package/Core/Standalone/Runtime/Internal/Openlog/TapCoreTracker.cs.meta

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