com.taptap.sdk.core 4.3.12 → 4.4.1

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

@@ -0,0 +1,237 @@
+using System;
+using System.Net;
+using System.Threading;
+
+namespace TapSDK.Core.Standalone.Internal.Http
+{
+    /// <summary>
+    /// 重试策略接口。
+    /// </summary>
+    public interface ITapHttpRetryStrategy
+    {
+        /// <summary>
+        /// 获取下次重试的时间（毫秒）。
+        /// </summary>
+        /// <param name="errorType">错误类型。</param>
+        /// <param name="e">异常信息。</param>
+        /// <returns>下次重试的时间（毫秒），如果不重试返回 -1。</returns>
+        long NextRetryMillis(AbsTapHttpException e);
+    }
+
+    /// <summary>
+    /// 后退策略接口。
+    /// </summary>
+    public interface ITapHttpBackoffStrategy
+    {
+        /// <summary>
+        /// 获取下一个后退的时间（毫秒）。
+        /// </summary>
+        /// <returns>下一个后退的时间（毫秒）。</returns>
+        long NextBackoffMillis();
+
+        /// <summary>
+        /// 判断是否可以重试无效时间。
+        /// </summary>
+        /// <returns>如果可以重试返回 true，否则返回 false。</returns>
+        bool CanInvalidTimeRetry();
+
+        /// <summary>
+        /// 重置策略状态。
+        /// </summary>
+        void Reset();
+    }
+
+    /// <summary>
+    /// HTTP 重试策略实现。
+    /// </summary>
+    public class TapHttpRetryStrategy
+    {
+        /// <summary>
+        /// 创建默认重试策略。
+        /// </summary>
+        /// <param name="backoffStrategy">后退策略。</param>
+        /// <returns>默认重试策略。</returns>
+        public static ITapHttpRetryStrategy CreateDefault(ITapHttpBackoffStrategy backoffStrategy)
+        {
+            return new Default(backoffStrategy);
+        }
+
+        /// <summary>
+        /// 创建不重试策略。
+        /// </summary>
+        /// <returns>不重试策略。</returns>
+        public static ITapHttpRetryStrategy CreateNone()
+        {
+            return new None();
+        }
+
+        private class None : ITapHttpRetryStrategy
+        {
+            public long NextRetryMillis(AbsTapHttpException e)
+            {
+                // 不重试返回 -1
+                return -1L;
+            }
+        }
+
+        private class Default : ITapHttpRetryStrategy
+        {
+            private readonly ITapHttpBackoffStrategy backoffStrategy;
+
+            public Default(ITapHttpBackoffStrategy backoffStrategy)
+            {
+                this.backoffStrategy = backoffStrategy;
+            }
+
+            public long NextRetryMillis(AbsTapHttpException e)
+            {
+                long nextRetryMillis = -1L;
+                if (e is TapHttpServerException se)
+                {
+                    // 处理服务器错误状态码
+                    if (se.StatusCode >= HttpStatusCode.InternalServerError && se.StatusCode <= (HttpStatusCode)599)
+                    {
+                        nextRetryMillis = backoffStrategy.NextBackoffMillis();
+                    }
+                    else if (TapHttpErrorConstants.ERROR_INVALID_TIME.Equals(se.ErrorData.Error))
+                    {
+                        // 修复时间并判断是否可以重试
+                        TapHttpTime.FixTime(se.TapHttpResponse.Now);
+                        if (backoffStrategy.CanInvalidTimeRetry())
+                        {
+                            nextRetryMillis = 0L; // 立马重试
+                        }
+                    }
+                    else if (TapHttpErrorConstants.ERROR_SERVER_ERROR.Equals(se.ErrorData.Error))
+                    {
+                        nextRetryMillis = backoffStrategy.NextBackoffMillis();
+                    }
+                }
+                else if (e is TapHttpInvalidResponseException ie)
+                {
+                    if (ie.StatusCode >= HttpStatusCode.InternalServerError && ie.StatusCode <= (HttpStatusCode)599)
+                    {
+                        nextRetryMillis = backoffStrategy.NextBackoffMillis();
+                    }
+                }
+                return nextRetryMillis;
+            }
+        }
+    }
+
+    /// <summary>
+    /// HTTP 后退策略实现。
+    /// </summary>
+    public class TapHttpBackoffStrategy
+    {
+        /// <summary>
+        /// 创建固定后退策略。
+        /// </summary>
+        /// <param name="maxCount">最大重试次数。</param>
+        /// <returns>固定后退策略。</returns>
+        public static ITapHttpBackoffStrategy CreateFixed(int maxCount)
+        {
+            return new Fixed(maxCount);
+        }
+
+        /// <summary>
+        /// 创建指数后退策略。
+        /// </summary>
+        /// <returns>指数后退策略。</returns>
+        public static ITapHttpBackoffStrategy CreateExponential()
+        {
+            return new Exponential();
+        }
+
+        /// <summary>
+        /// 创建不后退策略。
+        /// </summary>
+        /// <returns>不后退策略。</returns>
+        public static ITapHttpBackoffStrategy CreateNone()
+        {
+            return new None();
+        }
+
+        private abstract class Base : ITapHttpBackoffStrategy
+        {
+            protected int CanTimeDeltaRetry = 1;
+
+            public abstract long NextBackoffMillis();
+
+            public abstract void Reset();
+
+            /// <summary>
+            /// 判断是否可以重试无效时间。
+            /// </summary>
+            /// <returns>如果可以重试返回 true，否则返回 false。</returns>
+            public bool CanInvalidTimeRetry()
+            {
+                return Interlocked.CompareExchange(ref CanTimeDeltaRetry, 0, 1) == 1;
+            }
+        }
+
+        private class Fixed : Base
+        {
+            private readonly int _maxCount;
+            private int CurrentCount = 0;
+
+            public Fixed(int maxCount)
+            {
+                _maxCount = maxCount;
+            }
+
+            public override long NextBackoffMillis()
+            {
+                if (++CurrentCount < _maxCount)
+                {
+                    return 100L; // 固定的重试时间 100ms
+                }
+                return -1L; // 达到最大重试次数，返回 -1
+            }
+
+            public override void Reset()
+            {
+                CurrentCount = 0;
+                Interlocked.Exchange(ref CanTimeDeltaRetry, 1);
+            }
+        }
+
+        private class Exponential : Base
+        {
+            private static readonly long INIT_INTERVAL_MILLIS = 2 * 1000L; // 初始时间 2 秒
+            private static readonly long MAX_INTERVAL_MILLIS = 600 * 1000L; // 最大时间 600 秒
+            private static readonly int MULTIPLIER = 2; // 指数倍数
+
+            private long CurrentIntervalMillis = INIT_INTERVAL_MILLIS;
+
+            public override long NextBackoffMillis()
+            {
+                if (CurrentIntervalMillis * MULTIPLIER > MAX_INTERVAL_MILLIS)
+                {
+                    return MAX_INTERVAL_MILLIS; // 返回最大时间
+                }
+                CurrentIntervalMillis *= MULTIPLIER; // 增加当前时间
+                return CurrentIntervalMillis;
+            }
+
+            public override void Reset()
+            {
+                CurrentIntervalMillis = INIT_INTERVAL_MILLIS / MULTIPLIER; // 重置当前时间
+                Interlocked.Exchange(ref CanTimeDeltaRetry, 1);
+            }
+        }
+
+        private class None : Base
+        {
+            public override long NextBackoffMillis()
+            {
+                return -1L; // 不后退，返回 -1
+            }
+
+            public override void Reset()
+            {
+                Interlocked.Exchange(ref CanTimeDeltaRetry, 1);
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,137 @@
+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()},
+                    };
+                    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/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/Standalone/Runtime/Internal/Http/TapHttpUtils.cs

@@ -0,0 +1,166 @@
+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);
+        }
+    }
+
+    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);
+        }
+
+        internal 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, string content = null)
+        {
+            if (TapLogger.LogDelegate == null)
+            {
+                return;
+            }
+            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())}");
+                }
+            }
+            if (!string.IsNullOrEmpty(content))
+            {
+                sb.AppendLine($"Content: \n{content}");
+            }
+            sb.AppendLine("=== HTTP Request End ===");
+            tapLog.Log($"HTTP Request [{request.RequestUri.PathAndQuery}]", sb.ToString());
+        }
+
+        public static void PrintResponse(HttpResponseMessage response, string content = null)
+        {
+            if (TapLogger.LogDelegate == null)
+            {
+                return;
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("=== HTTP Response Start ===");
+            sb.AppendLine($"URL: {response.RequestMessage.RequestUri}");
+            sb.AppendLine($"Status Code: {response.StatusCode}");
+            if (!string.IsNullOrEmpty(content))
+            {
+                sb.AppendLine($"Content: {content}");
+            }
+            sb.AppendLine("=== HTTP Response End ===");
+            tapLog.Log($"HTTP Response [{response.RequestMessage.RequestUri.PathAndQuery}]", sb.ToString());
+        }
+
+    }
+}

package/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/Standalone/Runtime/Internal/Openlog/TapOpenlogHttpClient.cs

@@ -15,10 +15,10 @@ namespace TapSDK.Core.Standalone.Internal
     public class TapOpenlogHttpClient
     {
 
-        private const string HOST_CN = "openlog.xdrnd.cn";
-        private const string HOST_IO = "openlog.xdrnd.cn";
+        private static readonly string HOST_CN = "openlog.tapapis.cn";
+        private static readonly string HOST_IO = "openlog.tapapis.com";
 
-        private string GetHost()
+        private static string GetHost()
         {
             if (TapCoreStandalone.coreOptions.region == TapTapRegionType.CN)
             {
@@ -36,21 +36,11 @@ namespace TapSDK.Core.Standalone.Internal
 
         private static TapLog log = new TapLog(module: "Openlog.HttpClient");
 
-        private static System.Net.Http.HttpClient client;
+        private static HttpClient client;
 
         public TapOpenlogHttpClient()
         {
-            // var ip = "http://172.26.200.194:8888";
-            // ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) =>
-            // {
-            //     return true;
-            // };
-            // HttpClientHandler clientHandler = new HttpClientHandler
-            // {
-            //     Proxy = new WebProxy(ip)
-            // };
-            // client = new System.Net.Http.HttpClient(clientHandler);
-            client = new System.Net.Http.HttpClient();
+            client = new HttpClient();
         }
 
         public async Task<bool> Post(string path, byte[] content)
@@ -67,7 +57,6 @@ namespace TapSDK.Core.Standalone.Internal
             request.Headers.Add("x-log-bodyrawsize", content.Length.ToString());
 
             byte[] compressContent = LZ4Compress(content);
-            // byte[] compressContent = content;
 
             var contentMD5 = EncryptString(compressContent);
             request.Headers.Add("x-content-md5", contentMD5);
@@ -154,7 +143,7 @@ namespace TapSDK.Core.Standalone.Internal
             }
         }
 
-        private string BuildUrl(string path)
+        private static string BuildUrl(string path)
         {
             string url = $"https://{GetHost()}/{path}?client_id={TapCoreStandalone.coreOptions.clientId}";
             return url;

package/Standalone/Runtime/Internal/Openlog/TapOpenlogQueueBase.cs

@@ -104,7 +104,7 @@ namespace TapSDK.Core.Standalone.Internal
             }
             else
             {
-                log.Log("SendEvents success", JsonConvert.SerializeObject(logGroup));
+                log.Log("SendEvents success");
                 SaveEvents();
                 if (queueCount > MaxEvents)
                 {

package/Standalone/Runtime/Internal/service/ITapLoginService.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace TapSDK.Core.Standalone.Internal.Service
+{
+    public interface ITapLoginService
+    {
+        string ObtainAuthorizationAsync(string url, string method);
+    }
+}

package/Standalone/Runtime/Internal/service/ITapLoginService.cs.meta

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

package/Standalone/Runtime/Internal/service.meta

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