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

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

@@ -0,0 +1,437 @@
+using System.Net.Http;
+
+namespace TapSDK.Core.Standalone.Internal.Http
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Net.Http.Headers;
+    using System.Net.NetworkInformation;
+    using System.Text;
+    using System.Threading.Tasks;
+    using Newtonsoft.Json;
+    using TapSDK.Core.Internal.Log;
+
+    public class TapHttp
+    {
+
+        private static readonly string TAG = "Http";
+
+        private static readonly int MAX_GET_RETRY_COUNT = 3;
+
+        internal static readonly long CONNECT_TIMEOUT_MILLIS = 10 * 1000L;
+        internal static readonly long READ_TIMEOUT_MILLIS = 5 * 1000L;
+        internal static readonly long WRITE_TIMEOUT_MILLIS = 5 * 1000L;
+
+        public static readonly string HOST_CN = "https://tapsdk.tapapis.cn";
+        public static readonly string HOST_IO = "https://tapsdk.tapapis.com";
+
+        private static HttpClient client = new HttpClient{
+            // 默认超时 10 秒
+            Timeout = TimeSpan.FromMilliseconds(CONNECT_TIMEOUT_MILLIS)
+        };
+
+        private readonly TapHttpConfig httpConfig;
+
+        private readonly TapLog log = new TapLog(TAG);
+
+        private TapHttp() { }
+
+        internal TapHttp(TapHttpConfig httpConfig)
+        {
+            this.httpConfig = httpConfig;
+        }
+
+        public static TapHttpBuilder NewBuilder(string moduleName, string moduleVersion)
+        {
+            return new TapHttpBuilder(moduleName, moduleVersion);
+        }
+
+        public async void PostJson<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            Dictionary<string, object> json = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null,
+            Action<T> onSuccess = null,
+            Action<AbsTapHttpException> onFailure = null)
+        {
+            TapHttpResult<T> tapHttpResult = await PostJsonAsync<T>(
+                path: url,
+                headers: headers,
+                queryParams: queryParams,
+                json: json,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy
+            );
+            if (tapHttpResult.IsSuccess)
+            {
+                onSuccess?.Invoke(tapHttpResult.Data);
+            }
+            else
+            {
+                onFailure?.Invoke(tapHttpResult.HttpException);
+            }
+        }
+
+        public async void PostForm<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            Dictionary<string, string> form = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null,
+            Action<T> onSuccess = null,
+            Action<AbsTapHttpException> onFailure = null)
+        {
+            TapHttpResult<T> tapHttpResult = await PostFormAsync<T>(
+                url: url,
+                headers: headers,
+                queryParams: queryParams,
+                form: form,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy
+            );
+            if (tapHttpResult.IsSuccess)
+            {
+                onSuccess?.Invoke(tapHttpResult.Data);
+            }
+            else
+            {
+                onFailure?.Invoke(tapHttpResult.HttpException);
+            }
+        }
+
+        public async void Get<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null,
+            Action<T> onSuccess = null,
+            Action<Exception> onFailure = null
+        )
+        {
+            TapHttpResult<T> tapHttpResult = await GetAsync<T>(
+                url: url,
+                headers: headers,
+                queryParams: queryParams,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy
+           );
+            if (tapHttpResult.IsSuccess)
+            {
+                onSuccess?.Invoke(tapHttpResult.Data);
+            }
+            else
+            {
+                onFailure?.Invoke(tapHttpResult.HttpException);
+            }
+        }
+
+        public async Task<TapHttpResult<T>> GetAsync<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null
+        )
+        {
+            if (retryStrategy == null)
+            {
+                retryStrategy = TapHttpRetryStrategy.CreateDefault(TapHttpBackoffStrategy.CreateFixed(MAX_GET_RETRY_COUNT));
+            }
+            return await Request<T>(
+                url: url,
+                method: HttpMethod.Get,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy,
+                headers: headers,
+                queryParams: queryParams
+            );
+        }
+
+        public async Task<TapHttpResult<T>> PostJsonAsync<T>(
+            string path,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            object json = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null
+        )
+        {
+            if (retryStrategy == null)
+            {
+                retryStrategy = TapHttpRetryStrategy.CreateDefault(TapHttpBackoffStrategy.CreateNone());
+            }
+            string jsonStr = null;
+            if (json != null)
+            {
+                jsonStr = await Task.Run(() => JsonConvert.SerializeObject(json));
+            }
+            return await Request<T>(
+                url: path,
+                method: HttpMethod.Post,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy,
+                headers: headers,
+                queryParams: queryParams,
+                body: jsonStr
+            );
+        }
+
+        public async Task<TapHttpResult<T>> PostFormAsync<T>(
+            string url,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            Dictionary<string, string> form = null,
+            bool enableAuthorization = false,
+            ITapHttpRetryStrategy retryStrategy = null
+        )
+        {
+            if (retryStrategy == null)
+            {
+                retryStrategy = TapHttpRetryStrategy.CreateDefault(TapHttpBackoffStrategy.CreateNone());
+            }
+            return await Request<T>(
+                url: url,
+                method: HttpMethod.Post,
+                enableAuthorization: enableAuthorization,
+                retryStrategy: retryStrategy,
+                headers: headers,
+                queryParams: queryParams,
+                body: form
+            );
+        }
+
+        private async Task<TapHttpResult<T>> Request<T>(
+            string url,
+            HttpMethod method,
+            bool enableAuthorization,
+            ITapHttpRetryStrategy retryStrategy,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            object body = null
+        )
+        {
+            TapHttpResult<T> tapHttpResult;
+            long nextRetryMillis;
+            do
+            {
+                tapHttpResult = await RequestInner<T>(url, method, enableAuthorization, headers, queryParams, body);
+
+                if (tapHttpResult.IsSuccess)
+                {
+                    return tapHttpResult;
+                }
+
+                nextRetryMillis = retryStrategy.NextRetryMillis(tapHttpResult.HttpException);
+                if (nextRetryMillis > 0)
+                {
+                    log.Log($"Request failed, retry after {nextRetryMillis} ms");
+                    await Task.Delay(TimeSpan.FromMilliseconds(nextRetryMillis));
+                }
+
+            } while (nextRetryMillis >= 0L);
+
+            return tapHttpResult;
+        }
+
+        private async Task<TapHttpResult<T>> RequestInner<T>(
+            string path,
+            HttpMethod method,
+            bool enableAuthorization,
+            Dictionary<string, string> headers = null,
+            Dictionary<string, string> queryParams = null,
+            object body = null
+        )
+        {
+            if(!CheckNetworkConnection()){
+                return TapHttpResult<T>.NetworkError(new TapHttpNetworkErrorException("network error"));
+            }else{
+                TapLog.Log("current network is connected");
+            }
+            // 处理查询参数 
+            Dictionary<string, string> allQueryParams = new Dictionary<string, string>();
+            if (queryParams != null)
+            {
+                foreach (var param in queryParams)
+                {
+                    allQueryParams[param.Key] = param.Value;
+                }
+            }
+            var fixedQueryParams = httpConfig.Sign.GetFixedQueryParams();
+            if (fixedQueryParams != null)
+            {
+                foreach (var param in fixedQueryParams)
+                {
+                    allQueryParams[param.Key] = param.Value;
+                }
+            }
+            string host = HOST_CN;
+            if (httpConfig.Domain != null)
+            {
+                host = httpConfig.Domain;
+            }
+            else
+            {
+                if (TapCoreStandalone.coreOptions.region == TapTapRegionType.CN)
+                {
+                    host = HOST_CN;
+                }
+                else if (TapCoreStandalone.coreOptions.region == TapTapRegionType.Overseas)
+                {
+                    host = HOST_IO;
+                }
+            }
+            // 拼接查询参数
+            UriBuilder uriBuilder;
+            if (path.StartsWith("http://") || path.StartsWith("https://"))
+            {
+                uriBuilder = new UriBuilder(path);
+            }
+            else
+            {
+                if (!path.StartsWith("/"))
+                {
+                    path = "/" + path;
+                }
+                uriBuilder = new UriBuilder(uri: $"{host}{path}");
+            }
+
+            if (allQueryParams.Count > 0)
+            {
+                var queryBuilder = new StringBuilder();
+                foreach (var param in allQueryParams)
+                {
+                    // 使用 Uri.EscapeDataString 来编码参数的键和值
+                    queryBuilder.Append($"{Uri.EscapeDataString(param.Key)}={Uri.EscapeDataString(param.Value)}&");
+                }
+                // 移除末尾的 '&'
+                queryBuilder.Length -= 1;
+
+                uriBuilder.Query = queryBuilder.ToString();
+            }
+
+            var requestUri = uriBuilder.Uri;
+
+            // 创建 HttpRequestMessage
+            var request = new HttpRequestMessage
+            {
+                Method = method,
+                RequestUri = requestUri
+            };
+
+            // 处理请求头
+            Dictionary<string, string> allHeaders = new Dictionary<string, string>();
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                {
+                    allHeaders[header.Key] = header.Value;
+                }
+            }
+            Dictionary<string, string> fixedHeaders = httpConfig.Sign.GetFixedHeaders(requestUri.ToString(), method, httpConfig.ModuleName, httpConfig.ModuleVersion, enableAuthorization);
+            if (fixedHeaders != null)
+            {
+                foreach (var header in fixedHeaders)
+                {
+                    allHeaders[header.Key] = header.Value;
+                }
+            }
+            // 添加请求头
+            if (allHeaders != null)
+            {
+                foreach (var header in allHeaders)
+                {
+                    request.Headers.TryAddWithoutValidation(header.Key, header.Value.ToString());
+                }
+            }
+
+            // 根据请求类型设置请求体
+            if (method == HttpMethod.Post || method == HttpMethod.Put)
+            {
+                if (body != null)
+                {
+                    if (body is string jsonBody) // 处理 JSON 数据
+                    {
+                        StringContent requestContent = new StringContent(jsonBody);
+                        requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+                        request.Content = requestContent;
+                    }
+                    else if (body is Dictionary<string, string> formData) // 处理 Form 数据
+                    {
+                        request.Content = new FormUrlEncodedContent(formData);
+                    }
+                }
+            }
+            // 签算
+            httpConfig.Sign.Sign(request);
+            try
+            {
+                if (TapTapSDK.taptapSdkOptions.enableLog)
+                {
+                    TapHttpUtils.PrintRequest(client, request);
+                }
+                // 发送请求
+                HttpResponseMessage response = await client.SendAsync(request);
+                if (TapTapSDK.taptapSdkOptions.enableLog)
+                {
+                    TapHttpUtils.PrintResponse(response);
+                }
+                // 解析响应
+                return await httpConfig.Parser.Parse<T>(response);
+            }
+            catch (Exception ex)
+            {
+                // 捕获并处理请求异常
+                return TapHttpResult<T>.UnknownFailure(new TapHttpUnknownException(ex));
+            }
+        }
+
+        // 判断网络连接状态
+        private bool CheckNetworkConnection(){
+            try {
+                var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
+
+                foreach (var netInterface in networkInterfaces)
+                {
+                    // 忽略虚拟网卡
+                    if (netInterface.NetworkInterfaceType == NetworkInterfaceType.Loopback || 
+                        netInterface.NetworkInterfaceType == NetworkInterfaceType.Tunnel)
+                    {
+                        continue;
+                    }
+
+                    // 检查是否有网络连接
+                    if (netInterface.OperationalStatus == OperationalStatus.Up)
+                    {
+                        // 检查是否有有效的 IPv4 地址
+                        var ipProperties = netInterface.GetIPProperties();
+                        var ipv4Address = ipProperties.UnicastAddresses.FirstOrDefault(ip => ip.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
+
+                        if (ipv4Address != null)
+                        {
+                            // 有有效的 IP 地址，则说明已连接到网络
+                            if (netInterface.NetworkInterfaceType == NetworkInterfaceType.Ethernet)
+                            {
+                                return true; // 有线连接
+                            }
+                            else if (netInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)
+                            {
+                                return true; // 无线连接
+                            }
+                        }
+                    }
+                }
+
+                return false; // 无连接
+            }catch(Exception e){
+                TapLog.Log("checkout network connected error = " + e);
+                // 发生异常时，当做有网处理
+                return true;
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,92 @@
+using System;
+
+namespace TapSDK.Core.Standalone.Internal.Http
+{
+    public class TapHttpBuilder
+    {
+        private readonly string moduleName;
+        private readonly string moduleVersion;
+
+        private string domain = null;
+
+        private ITapHttpSign sign = null;
+        private ITapHttpParser parser = null;
+
+        private long connectTimeoutMillis = TapHttp.CONNECT_TIMEOUT_MILLIS;
+        private long readTimeoutMillis = TapHttp.READ_TIMEOUT_MILLIS;
+        private long writeTimeoutMillis = TapHttp.WRITE_TIMEOUT_MILLIS;
+
+        public TapHttpBuilder(string moduleName, string moduleVersion)
+        {
+            this.moduleName = moduleName ?? throw new ArgumentNullException(nameof(moduleName));
+            this.moduleVersion = moduleVersion ?? throw new ArgumentNullException(nameof(moduleVersion));
+        }
+
+        public TapHttp Build()
+        {
+            TapHttpConfig httpConfig = new TapHttpConfig
+            {
+                ModuleName = moduleName,
+                ModuleVersion = moduleVersion,
+                Domain = domain,
+                Sign = sign ?? TapHttpSign.CreateDefaultSign(),
+                Parser = parser ?? TapHttpParser.CreateDefaultParser(),
+                ConnectTimeoutMillis = connectTimeoutMillis,
+                ReadTimeoutMillis = readTimeoutMillis,
+                WriteTimeoutMillis = writeTimeoutMillis,
+            };
+            return new TapHttp(httpConfig);
+        }
+
+        public TapHttpBuilder ConnectTimeout(long connectTimeoutMillis)
+        {
+            this.connectTimeoutMillis = connectTimeoutMillis;
+            return this;
+        }
+
+        public TapHttpBuilder ReadTimeout(long readTimeoutMillis)
+        {
+            this.readTimeoutMillis = readTimeoutMillis;
+            return this;
+        }
+
+        public TapHttpBuilder WriteTimeout(long writeTimeoutMillis)
+        {
+            this.writeTimeoutMillis = writeTimeoutMillis;
+            return this;
+        }
+
+        public TapHttpBuilder Domain(string domain)
+        {
+            this.domain = domain;
+            return this;
+        }
+
+        public TapHttpBuilder Sign(ITapHttpSign sign)
+        {
+            this.sign = sign;
+            return this;
+        }
+
+        public TapHttpBuilder Parser(ITapHttpParser parser)
+        {
+            this.parser = parser;
+            return this;
+        }
+
+    }
+
+    internal class TapHttpConfig
+    {
+        public string ModuleName { get; set; }
+        public string ModuleVersion { get; set; }
+        public string Domain { get; set; }
+        public ITapHttpSign Sign { get; set; }
+        public ITapHttpParser Parser { get; set; }
+        public ITapHttpParser RetryStrategy { get; set; }
+        public long ConnectTimeoutMillis { get; set; }
+        public long ReadTimeoutMillis { get; set; }
+        public long WriteTimeoutMillis { get; set; }
+    }
+
+}

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

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

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

@@ -0,0 +1,114 @@
+
+namespace TapSDK.Core.Standalone.Internal.Http
+{
+    /// <summary>
+    /// HTTP 错误常量类。
+    /// </summary>
+    public static class TapHttpErrorConstants
+    {
+
+        // --------------------------------------------------------------------------------------------
+        // 下面的错误信息是服务器端 [data.error] 字段的枚举
+        // --------------------------------------------------------------------------------------------
+
+        /// <summary>
+        /// 400 请阅读：[通用 API 人机验证协议](https://xindong.atlassian.net/wiki/spaces/TAP/pages/66032081)。
+        /// </summary>
+        public const string ERROR_CAPTCHA_NEEDS = "captcha.needs";
+
+        /// <summary>
+        /// 400 人机验证未通过。
+        /// </summary>
+        public const string ERROR_CAPTCHA_FAILED = "captcha.failed";
+
+        /// <summary>
+        /// 403 用户冻结。
+        /// </summary>
+        public const string ERROR_USER_IS_DEACTIVATED = "user_is_deactivated";
+
+        /// <summary>
+        /// 400 请求缺少某个必需参数，包含一个不支持的参数或参数值，或者格式不正确。
+        /// </summary>
+        public const string ERROR_INVALID_REQUEST = "invalid_request";
+
+        /// <summary>
+        /// 404 请求失败，请求所希望得到的资源未被在服务器上发现。在参数相同的情况下，不应该重复请求。
+        /// </summary>
+        public const string ERROR_NOT_FOUND = "not_found";
+
+        /// <summary>
+        /// 403 用户没有对当前动作的权限，引导重新身份验证并不能提供任何帮助，而且这个请求也不应该被重复提交。
+        /// </summary>
+        public const string ERROR_FORBIDDEN = "forbidden";
+
+        /// <summary>
+        /// 500 服务器出现异常情况，可稍等后重新尝试请求，但需有尝试上限，建议最多 3 次，如一直失败，则中断并告知用户。
+        /// </summary>
+        public const string ERROR_SERVER_ERROR = "server_error";
+
+        /// <summary>
+        /// 400 客户端时间不正确，应请求服务器时间重新构造。
+        /// </summary>
+        public const string ERROR_INVALID_TIME = "invalid_time";
+
+        /// <summary>
+        /// 400 请求是重放的。
+        /// </summary>
+        public const string ERROR_REPLAY_ATTACKS = "replay_attacks";
+
+        /// <summary>
+        /// 401 client_id、client_secret 参数无效。
+        /// </summary>
+        public const string ERROR_INVALID_CLIENT = "invalid_client";
+
+        /// <summary>
+        /// 400 提供的 Access Grant 是无效的、过期的或已撤销的，例如: Device Code 无效（一个设备授权码只能使用一次）等。
+        /// </summary>
+        public const string ERROR_INVALID_GRANT = "invalid_grant";
+
+        /// <summary>
+        /// 400 服务器不支持 grant_type 参数的值。
+        /// </summary>
+        public const string ERROR_UNSUPPORTED_GRANT_TYPE = "unsupported_grant_type";
+
+        /// <summary>
+        /// 400 服务器不支持 response_type 参数的值。
+        /// </summary>
+        public const string ERROR_UNSUPPORTED_RESPONSE_TYPE = "unsupported_response_type";
+
+        /// <summary>
+        /// 400 服务器不支持 secret_type 参数的值。
+        /// </summary>
+        public const string ERROR_UNSUPPORTED_SECRET_TYPE = "unsupported_secret_type";
+
+        /// <summary>
+        /// 400 Device Flow 中，设备通过 Device Code 换取 Access Token 的接口过于频繁。
+        /// </summary>
+        public const string ERROR_SLOW_DOWN = "slow_down";
+
+        /// <summary>
+        /// 429 登录尝试次数过多，请稍后重试，用于 password 模式下出错次数过多。
+        /// </summary>
+        public const string ERROR_TOO_MANY_LOGIN_ATTEMPTS = "too_many_login_attempts";
+
+        /// <summary>
+        /// 401 授权服务器拒绝请求，这个状态出现在拿着 token 请求用户资源时，如出现，客户端应退出本地的用户登录信息，引导用户重新登录。
+        /// </summary>
+        public const string ERROR_ACCESS_DENIED = "access_denied";
+
+        /// <summary>
+        /// 401 认证内容无效 grant_type 为 password 的模式下，用户名或密码错误。
+        /// </summary>
+        public const string ERROR_INVALID_CREDENTIALS = "invalid_credentials";
+
+        /// <summary>
+        /// 400 Device Flow 中，用户还没有对 Device Code 完成授权操作，按 interval 要求频率继续轮询，直到 expires_in 过期。
+        /// </summary>
+        public const string ERROR_AUTHORIZATION_PENDING = "authorization_pending";
+
+        /// <summary>
+        /// 服务端业务异常，如：防沉迷 token 失效（code=20000）。
+        /// </summary>
+        public const string ERROR_BUSINESS_ERROR = "business_code_error";
+    }
+}

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

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