com.xd.sdk.common 0.0.1

package/Runtime/Internal/Http/Response/BaseResponse.cs

@@ -0,0 +1,17 @@
+using System.Net.Http.Headers;
+using LC.Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal {
+    public class BaseResponse {
+        [JsonProperty("code")]
+        public int Code { get; private set; }
+
+        [JsonProperty("msg")]
+        public string Message { get; private set; }
+
+        [JsonProperty("detail")]
+        public string Detail { get; private set; }
+
+        public HttpResponseHeaders Headers { get; set; }
+    }
+}

package/Runtime/Internal/Http/Response/BaseResponse.cs.meta

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

package/Runtime/Internal/Http/Response/ErrorResponse.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using LC.Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal {
+    public class ErrorResponse : BaseResponse {
+        [JsonProperty("data")]
+        public Dictionary<string, object> Data { get; private set; }
+    }
+}

package/Runtime/Internal/Http/Response/ErrorResponse.cs.meta

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

package/Runtime/Internal/Http/Response.meta

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

package/Runtime/Internal/Http/XDCommonHttpConfig.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal {
+    public class XDCommonHttpConfig {
+        private static IXDCommonHttpConfig platformWrapper;
+
+        public static void Init() {
+            var interfaceType = typeof(IXDCommonHttpConfig);
+            var platformInterfaceType = AppDomain.CurrentDomain.GetAssemblies()
+                .SelectMany(assembly => assembly.GetTypes())
+                .FirstOrDefault(clazz => interfaceType.IsAssignableFrom(clazz) && clazz.IsClass);
+            if (platformInterfaceType != null) {
+                platformWrapper = Activator.CreateInstance(platformInterfaceType) as IXDCommonHttpConfig;
+
+                XDHttpClientFactory.RegisterQueryParamsFunc(GetCommonQueryParams);
+            } else {
+                XDGLogger.Error($"No class implements {interfaceType} Type. Current Platform: {Application.platform}, if you are using Editor, please check if you have installed XDSDK pc module.");
+            }
+        }
+
+        public static Dictionary<string, string> GetCommonQueryParams(string url, long timestamp) {
+            return platformWrapper.GetCommonQueryParams(url, timestamp);
+        }
+    }
+}

package/Runtime/Internal/Http/XDCommonHttpConfig.cs.meta

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

package/Runtime/Internal/Http/XDDelegatingHandler.cs

@@ -0,0 +1,41 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace XD.SDK.Common.Internal
+{
+    public class XdDelegatingHandler : DelegatingHandler
+    {
+        public XdDelegatingHandler(HttpMessageHandler innerHandler) :
+            base(innerHandler)
+        {
+        }
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
+            CancellationToken cancellationToken)
+        {
+            if (XDUtility.UseProxy && XDUtility.Proxy != null)
+            {
+                if (GetInnerMostHandler(this) is HttpClientHandler httpClientHandler)
+                {
+                    if (httpClientHandler.Proxy == null)
+                    {
+                        httpClientHandler.Proxy = XDUtility.Proxy;
+                    }
+                }
+            }
+
+            return await base.SendAsync(request, cancellationToken);
+        }
+
+        private HttpMessageHandler GetInnerMostHandler(HttpMessageHandler handler)
+        {
+            if (handler is DelegatingHandler delegatingHandler)
+            {
+                return GetInnerMostHandler(delegatingHandler.InnerHandler);
+            }
+
+            return handler;
+        }
+    }
+}

package/Runtime/Internal/Http/XDDelegatingHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 340304c606a8437b85f6d24c2f17d663
+timeCreated: 1716776700

package/Runtime/Internal/Http/XDHttpClient.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Linq;
+using LC.Newtonsoft.Json;
+using LeanCloud.Common;
+
+namespace XD.SDK.Common.Internal {
+    public class XDHttpClient {
+        internal string Host { get; set; }
+
+        internal HttpClient Client { get; set; }
+
+        public Task<T> Get<T>(string path,
+            Dictionary<string, object> headers = null,
+            Dictionary<string, object> queryParams = null) where T : BaseResponse {
+
+            return Request<T>(path, HttpMethod.Get, headers, null, queryParams);
+        }
+
+        public Task<T> Post<T>(string path,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) where T : BaseResponse {
+            return Request<T>(path, HttpMethod.Post, headers, data, queryParams);
+        }
+
+        public Task<T> Put<T>(string path,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) where T : BaseResponse {
+            return Request<T>(path, HttpMethod.Put, headers, data, queryParams);
+        }
+
+        public Task Delete(string path,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) {
+            return Request<BaseResponse>(path, HttpMethod.Delete, headers, data, queryParams);
+        }
+
+        async Task<T> Request<T>(string path,
+            HttpMethod method,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) where T : BaseResponse {
+            HttpResponseMessage response = await Request(path, method, headers, data, queryParams);
+            string resultString = await response.Content.ReadAsStringAsync();
+            XDHttpUtils.PrintResponse(response, resultString);
+            response.Dispose();
+
+            if (response.IsSuccessStatusCode) {
+                T ret = JsonConvert.DeserializeObject<T>(resultString,
+                    LCJsonConverter.Default);
+                ret.Headers = response.Headers;
+                return ret;
+            }
+
+            throw HandleErrorResponse(response.StatusCode, resultString);
+        }
+
+        public async Task<HttpResponseMessage> Request(string path,
+            HttpMethod method,
+            Dictionary<string, object> headers = null,
+            object data = null,
+            Dictionary<string, object> queryParams = null) {
+            string url = path;
+            long timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+
+            if (!url.StartsWith("http://") && !url.StartsWith("https://")) {
+                // 临时支持完整 url
+                url = BuildUrl(path, queryParams, timestamp);
+            }
+            HttpRequestMessage request = new HttpRequestMessage {
+                RequestUri = new Uri(url),
+                Method = method,
+            };
+            FillHeaders(request.Headers, headers);
+
+            Dictionary<string, string> commonHeaders = await XDHttpClientFactory.GetHeaders(request, timestamp);
+            foreach (KeyValuePair<string, string> kv in commonHeaders) {
+                request.Headers.Add(kv.Key, kv.Value);
+            }
+
+            string content = null;
+            if (data != null) {
+                content = JsonConvert.SerializeObject(data);
+                StringContent requestContent = new StringContent(content);
+                requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+                request.Content = requestContent;
+            }
+
+            try {
+                HttpResponseMessage response = await Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+                return response;
+            } finally {
+                XDHttpUtils.PrintRequest(Client, request, content);
+                request.Dispose();
+            }
+        }
+
+        static XDException HandleErrorResponse(HttpStatusCode statusCode, string responseContent) {
+            int httpStatusCode = (int)statusCode;
+            string message = responseContent;
+            Exception ex = null;
+            try {
+                // 尝试获取 LeanCloud 返回错误信息
+                ErrorResponse error = JsonConvert.DeserializeObject<ErrorResponse>(responseContent,
+                    LCJsonConverter.Default);
+                if (error?.Code == 0 && error.Data == null && string.IsNullOrEmpty(error.Message) && string.IsNullOrEmpty(error.Detail))
+                {
+                    ex = new XDHttpException(httpStatusCode, httpStatusCode, message);
+                }
+                else
+                {
+                    if (error != null) ex = new XDHttpException(httpStatusCode, error.Code, error.Message, error.Data);
+                }
+            } catch (Exception e) {
+                XDGLogger.Debug(e.ToString());
+            }
+            throw ex ?? new XDHttpException(httpStatusCode, httpStatusCode, message);
+        }
+
+        string BuildUrl(string path, Dictionary<string, object> queryParams, long timestamp) {
+            StringBuilder urlSB = new StringBuilder(Host.TrimEnd('/'));
+            urlSB.Append($"/{path}");
+            string url = urlSB.ToString();
+
+            Dictionary<string, object> queries = new Dictionary<string, object>();
+
+            Dictionary<string, string> commonQueryParams = XDHttpClientFactory.GetQueryParams(url, timestamp);
+            if (commonQueryParams != null) {
+                commonQueryParams.ToList().ForEach(pair => queries[pair.Key] = pair.Value);
+            }
+
+            if (queryParams != null) {
+                queryParams.ToList().ForEach(pair => queries[pair.Key] = pair.Value);
+            }
+            
+            if (queries.Count > 0) {
+                url = $"{url}?{XDUrlUtils.ToQueryString(queries)}";
+            }
+
+            return url;
+        }
+
+        static void FillHeaders(HttpRequestHeaders headers, Dictionary<string, object> reqHeaders = null) {
+            // 额外 headers
+            if (reqHeaders != null) {
+                foreach (KeyValuePair<string, object> kv in reqHeaders) {
+                    headers.Add(kv.Key, kv.Value.ToString());
+                }
+            }
+        }
+    }
+}

package/Runtime/Internal/Http/XDHttpClient.cs.meta

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

package/Runtime/Internal/Http/XDHttpClientFactory.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+
+namespace XD.SDK.Common.Internal {
+    public class XDHttpClientFactory {
+        private static readonly string CnBaseURL = "https://xdsdk-6.xd.cn";
+        private static readonly string GlobalBaseURL = "https://xdsdk-intnl-6.xd.com";
+
+        internal static List<Func<string, long, Dictionary<string, string>>> QueryParamsFuncs { get; private set; }
+
+        internal static List<Func<HttpRequestMessage, long, Task<Dictionary<string, string>>>> HeadersAsyncFuncs { get; private set; }
+
+        private static volatile XDHttpClient _xdDefaultClient;
+        private static readonly object Locker = new object();
+
+        static XDHttpClientFactory() {
+            QueryParamsFuncs = new List<Func<string, long, Dictionary<string, string>>>();
+            HeadersAsyncFuncs = new List<Func<HttpRequestMessage, long, Task<Dictionary<string, string>>>>();
+        }
+
+        public static XDHttpClient GetDefaultXdHttpClient()
+        {
+            if (_xdDefaultClient != null) return _xdDefaultClient;
+            lock (Locker)
+            {
+                if (_xdDefaultClient == null) {
+                    var defaultHost = XDConfigs.IsCN ? CnBaseURL : GlobalBaseURL;
+                    _xdDefaultClient = CreateClient(defaultHost);
+                }
+            }
+
+            return _xdDefaultClient;
+        }
+        
+        public static XDHttpClient CreateClient(string host , HttpMessageHandler handler = null) {
+            HttpClient httpClient;
+            if (handler == null) {
+                httpClient = new HttpClient(CreateDefaultHandler());
+            } else {
+                httpClient = new HttpClient(handler);
+            }
+            httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            httpClient.Timeout = TimeSpan.FromSeconds(10);
+            XDHttpClient client = new XDHttpClient {
+                Host = host,
+                Client = httpClient
+            };
+            return client;
+        }
+
+        public static void RegisterQueryParamsFunc(Func<string, long, Dictionary<string, string>> func) {
+            QueryParamsFuncs.Add(func);
+        }
+
+        public static void RegisterHeadersTaskFunc(Func<HttpRequestMessage, long, Task<Dictionary<string, string>>> asyncFunc) {
+            HeadersAsyncFuncs.Add(asyncFunc);
+        }
+
+        public static Dictionary<string, string> GetQueryParams(string url, long timestamp) {
+            return QueryParamsFuncs.Select(func => func.Invoke(url, timestamp))
+                .SelectMany(dict => dict)
+                .GroupBy(kvp => kvp.Key)
+                .ToDictionary(g => g.Key, g => g.Last().Value);
+        }
+
+        public static async Task<Dictionary<string, string>> GetHeaders(HttpRequestMessage request, long timestamp) {
+            Dictionary<string, string>[] results = await Task.WhenAll(HeadersAsyncFuncs.Select(func => func.Invoke(request, timestamp)));
+            return results.SelectMany(dict => dict)
+                .GroupBy(kvp => kvp.Key)
+                .ToDictionary(g => g.Key, g => g.Last().Value);
+        }
+
+        private static XdDelegatingHandler CreateDefaultHandler()
+        {
+            return new XdDelegatingHandler(new HttpClientHandler());
+        }
+    }
+}

package/Runtime/Internal/Http/XDHttpClientFactory.cs.meta

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

package/Runtime/Internal/Http/XDHttpUtils.cs

@@ -0,0 +1,65 @@
+using System.Linq;
+using System.Text;
+using System.Net.Http;
+using System.Net.Http.Headers;
+
+namespace XD.SDK.Common.Internal {
+    public static class XDHttpUtils {
+        public static void PrintRequest(HttpClient client, HttpRequestMessage request, string content = null) {
+            if (XDGLogger.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: {content}");
+            }
+            sb.AppendLine("=== HTTP Request End ===");
+            XDGLogger.Debug(sb.ToString());
+        }
+
+        public static void PrintResponse(HttpResponseMessage response, string content = null) {
+            if (XDGLogger.LogDelegate == null) {
+                return;
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("=== HTTP Response Start ===");
+            sb.AppendLine($"URL: {response.RequestMessage.RequestUri}");
+            sb.AppendLine($"Status Code: {response.StatusCode}");
+            sb.AppendLine($"Headers: ");
+            foreach (var header in response.Headers) {
+                sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
+            }
+            if (response.Content.Headers != null) {
+                foreach (var header in response.Content.Headers) {
+                    sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
+                }
+            }
+            if (!string.IsNullOrEmpty(content)) {
+                sb.AppendLine($"Content: {content}");
+            }
+            sb.AppendLine("=== HTTP Response End ===");
+            XDGLogger.Debug(sb.ToString());
+        }
+    }
+}

package/Runtime/Internal/Http/XDHttpUtils.cs.meta

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

package/Runtime/Internal/Http/XDUrlUtils.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Net;
+using System.Linq;
+using System.Collections.Specialized;
+using System.Collections.Generic;
+
+namespace XD.SDK.Common.Internal {
+    public static class XDUrlUtils {
+        public static NameValueCollection ParseQueryString(string query) {
+            NameValueCollection nvc = new NameValueCollection();
+
+            if (query.StartsWith("?")) {
+                query = query.Substring(1);
+            }
+
+            foreach (var param in query.Split('&')) {
+                string[] pair = param.Split('=');
+                if (pair.Length == 2) {
+                    string key = WebUtility.UrlDecode(pair[0]);
+                    string value = WebUtility.UrlDecode(pair[1]);
+                    nvc[key] = value;
+                }
+            }
+
+            return nvc;
+        }
+
+        public static string ToQueryString(Dictionary<string, object> queryParams) {
+            return string.Join("&",
+                queryParams.Where(kvp => kvp.Key != null && kvp.Value != null)
+                    .Select(kvp => $"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value.ToString())}")
+            );
+        }
+    }
+}

package/Runtime/Internal/Http/XDUrlUtils.cs.meta

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

package/Runtime/Internal/Http.meta

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

package/Runtime/Internal/IXDGCommon.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+
+namespace XD.SDK.Common
+{
+    public interface IXDGCommon
+    {
+        string UserId { get; set; }
+
+        void InitSDK(Action<bool, string> callback);
+
+        void IsInitialized(Action<bool> callback);
+        
+        void SetLanguage(LangType langType);
+
+        void Share(ShareFlavors shareFlavors, string uri, XDGShareCallback callback);
+
+        void Share(ShareFlavors shareFlavors, string uri, string message, XDGShareCallback callback);
+
+        void Report(string serverId, string roleId, string roleName);
+
+        void TrackRole(string serverId, string roleId, string roleName, int level);
+
+        void TrackUser(string userId = null);
+
+        void TrackEvent(string eventName, Dictionary<string,object> properties = null);
+
+        void EventCompletedTutorial();
+        
+        void EventCreateRole();
+
+        void GetVersionName(Action<string> callback);
+
+        void TrackAchievement();
+
+        void SetCurrentUserPushServiceEnable(bool enable);
+
+        void IsCurrentUserPushServiceEnable(Action<bool> callback);
+
+        void StoreReview();
+
+        void ShowLoading();
+
+        void HideLoading();
+
+        void GetRegionInfo(Action<XDGRegionInfoWrapper> callback);
+
+        void DisableAgreementUI();
+
+        void ReplaceChannelAndVersion(string channel, string gameVersion);
+
+        void GetAgreementList(Action<List<XDGAgreement>> callback);
+
+        void ShowDetailAgreement(string agreementUrl);
+
+        void SetExitHandler(Action onExitHandler);
+    }
+}

package/Runtime/Internal/IXDGCommon.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 252ff17631a84989a79fecb1f60937f1
+timeCreated: 1672739089

package/Runtime/Internal/IXDGSettings.cs

@@ -0,0 +1,7 @@
+namespace XD.SDK.Common
+{
+    public interface IXDGSettings
+    {
+        void SetTargetCountryOrRegion(string region);
+    }
+}

package/Runtime/Internal/IXDGSettings.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 200eac38e4244da59efad1de2b2cd8f1
+timeCreated: 1719483002

package/Runtime/Internal/LangType.cs

@@ -0,0 +1,20 @@
+namespace XD.SDK.Common
+{
+    public enum LangType {
+        AUTO = -1,  // 默认
+        ZH_CN = 0,  // 简体中文
+        ZH_TW = 1,  // 繁体中文
+        EN = 2,     // 英文
+        TH = 3,     // 泰文
+        ID = 4,     // 印尼文
+        KR = 5,     // 韩语
+        JP = 6,     // 日语
+        DE = 7,     // 德语
+        FR = 8,     // 法语
+        PT = 9,     // 葡萄牙语
+        ES = 10,    // 西班牙语
+        TR = 11,    // 土耳其语
+        RU = 12,    // 俄罗斯语
+        VI = 13,    // 越南
+    }
+}

package/Runtime/Internal/LangType.cs.meta

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