com.xd.sdk.common 0.0.1 → 0.0.10-alpha

package/Runtime/Internal/Mobile/CommonFeaturesImpl.cs

@@ -0,0 +1,311 @@
+#if UNITY_ANDROID || UNITY_IOS
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Newtonsoft.Json;
+using UnityEngine;
+using XD.SDK.Common.Internal.Mobile.Bridge;
+using XD.SDK.Common.Internal.Events;
+
+namespace XD.SDK.Common.Internal.Mobile
+{
+    public class CommonFeaturesImpl : IXDGCommonExtended
+    {
+        private static CommonFeaturesImpl instance;
+        private static readonly object lockObj = new object();
+
+        public static CommonFeaturesImpl Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    lock (lockObj)
+                    {
+                        if (instance == null)
+                        {
+                            instance = new CommonFeaturesImpl();
+                        }
+                    }
+                }
+
+                return instance;
+            }
+        }
+
+        private CommonFeaturesImpl()
+        {
+            EngineBridge.GetInstance()
+                .Register(BridgeConstants.Common.SERVICE_NAME, BridgeConstants.Common.SERVICE_IMPL);
+        }
+
+        public void InitSDK(XDGInitParam param, Action<bool, string> callback)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Common.BRIDGE_NAME)
+                .Method("initSDK")
+                .Args(XDUtility.BridgeArgToDictionary("initSDK", param))
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+
+            EngineBridge.GetInstance().CallHandler(command, (result) =>
+            {
+                XDGLogger.Debug("===> Init XDG SDK result: " + result.ToJson());
+                var xdgError = result.Parse2XDGError();
+                if (!XDGTool.CheckResultSuccess(result))
+                {
+                    callback(false, xdgError?.ErrorMsg ?? "Init SDK Fail");
+                    XDGLogger.Error("初始化失败 result：" + result.ToJson());
+                    return;
+                }
+
+                var resultDic = XDGJson.Deserialize(result.content) as Dictionary<string, object>;
+                var isSuccess = XDDictionary.GetValue<bool>(resultDic, "success");
+                var message = XDDictionary.GetValue<string>(resultDic, "message");
+
+                if (isSuccess)
+                {
+                    _SetGameActivity();
+
+                    _InitTdsSDK();
+                }
+
+                callback(isSuccess, message);
+            });
+        }
+
+        private static void _InitTdsSDK()
+        {
+            string config = null;
+#if UNITY_ANDROID
+            using (var commonBridgeClass = new AndroidJavaClass(BridgeConstants.Common.SERVICE_IMPL))
+            {
+                config =  commonBridgeClass.CallStatic<string>("getTapSDKConfig");
+            }
+#elif UNITY_IOS
+            IntPtr ptr = XDCommonConfigs();
+            config = Marshal.PtrToStringAnsi(ptr);
+#endif
+            if (string.IsNullOrEmpty(config))
+            {
+                XDGLogger.Warn("[CommonFeature] get Mobile TapSDK Config Empty!");
+                return;
+            }
+            MainThreadDispatcher.RunOnMainThread(() =>
+            {
+                var commonConfig = JsonConvert.DeserializeObject<CommonConfig>(config);
+                XDGEventBus.Publish(XDGEvents.TdsSDKInit,
+                    commonConfig?.TapConfig?.ClientId,
+                    commonConfig?.TapConfig?.ClientToken,
+                    commonConfig?.TapConfig?.ServerUrl);
+            });
+        }
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern IntPtr XDCommonConfigs();
+#endif
+
+        private static void _SetGameActivity()
+        {
+#if UNITY_ANDROID
+            using (var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
+            {
+                var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
+                using (var commonBridgeClass = new AndroidJavaClass(BridgeConstants.Common.SERVICE_IMPL))
+                {
+                    commonBridgeClass.CallStatic("setGameActivity", currentActivity);
+                }
+            }
+#endif
+        }
+
+        public bool IsInitialized()
+        {
+#if UNITY_ANDROID
+            using (var commonBridgeClass = new AndroidJavaClass(BridgeConstants.Common.SERVICE_IMPL))
+            {
+                return commonBridgeClass.CallStatic<bool>("isInitialized");
+            }
+#elif UNITY_IOS
+            return XDCommonIsInitialized();
+#endif
+            return false;
+        }
+
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern bool XDCommonIsInitialized();
+
+#endif
+
+        public void SetLanguage(LangType langType)
+        {
+            XDGLogger.Debug("===> SetLanguage langType: " + langType);
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Common.BRIDGE_NAME)
+                .Method("setLanguage")
+                .Args("langType", (int)langType)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void StoreReview()
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Common.BRIDGE_NAME)
+                .Method("storeReview")
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug("===> StoreReview");
+        }
+
+        public void TrackRole(XDGRoleInfo role)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Common.BRIDGE_NAME)
+                .Method("trackRole")
+                .Args(XDUtility.BridgeArgToDictionary("trackRole", role))
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void TrackEvent(string eventName, Dictionary<string, object> properties = null)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Common.BRIDGE_NAME)
+                .Method("trackEvent")
+                .Args("eventName", eventName)
+                .Args("properties", properties)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug($"===> TrackEvent:  {eventName} {properties}");
+        }
+
+        public void PreloadWebPage(string url)
+        {
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Common.BRIDGE_NAME)
+                .Method("preload")
+                .Args("preload", url)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void OpenWebPage(string url, Action<WebActionEnum, Dictionary<string, object>> callback)
+        {
+            XDGLogger.Debug("[unity 打开 Web Url:");
+            var command = new Command.Builder()
+                .Service(BridgeConstants.Common.BRIDGE_NAME)
+                .Method("openWebPage")
+                .Args("openWebPage", url)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result =>
+            {
+                XDGLogger.Debug("===> OpenWebPage: " + result.ToJson());
+                if (!XDGTool.CheckResultSuccess(result))
+                {
+                    return;
+                }
+
+                var content = result.content;
+                var dicStrStr = XDGJson.Deserialize(content);
+                var dic = dicStrStr as Dictionary<string, object>;
+                var actionType = XDDictionary.GetValue<int>(dic, "actionType");
+                var dataStr = XDDictionary.GetValue<string>(dic, "actionData");
+                var dataDic = XDGJson.Deserialize(dataStr) as Dictionary<string, object>;
+                callback?.Invoke((WebActionEnum)actionType, dataDic);
+            });
+        }
+
+        public void TrackUser(string userId)
+        {
+            // 不需要实现
+        }
+
+        public bool IsCn()
+        {
+#if UNITY_ANDROID
+            using (var commonBridgeClass = new AndroidJavaClass(BridgeConstants.Common.SERVICE_IMPL))
+            {
+                return commonBridgeClass.CallStatic<bool>("isCN");
+            }
+#elif UNITY_IOS
+            return XDCommonBridgeIsCN();
+#endif
+            return false;
+        }
+
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern bool XDCommonBridgeIsCN();
+#endif
+
+        public Dictionary<string, string> GetCommonQueryParams(string url, long timestamp)
+        {
+            string fullUrl;
+#if UNITY_ANDROID
+            using (var commonBridgeClass = new AndroidJavaClass(BridgeConstants.Common.SERVICE_IMPL))
+            {
+                fullUrl = commonBridgeClass.CallStatic<string>("buildRequestUrlString", url, timestamp);
+            }
+#elif UNITY_IOS
+            IntPtr ptr = XDCommonBridgeGetCommonQueryString(url, timestamp);
+            fullUrl = Marshal.PtrToStringAnsi(ptr);
+#endif
+            var uri = new Uri(fullUrl);
+            var queries = XDUrlUtils.ParseQueryString(uri.Query);
+            return queries.AllKeys.ToDictionary(key => Uri.UnescapeDataString(key),
+                key => Uri.UnescapeDataString(queries[key]));
+        }
+
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern IntPtr XDCommonBridgeGetCommonQueryString(string url, long timestamp);
+#endif
+
+        public void SetTargetCountryOrRegion(string countryOrRegion)
+        {
+#if UNITY_ANDROID
+            using (var commonBridgeClass = new AndroidJavaClass(BridgeConstants.Common.SERVICE_IMPL))
+            {
+                commonBridgeClass.CallStatic("setTargetCountryOrRegion", countryOrRegion);
+            }
+#elif UNITY_IOS
+            XDCommonTargetCountryOrRegion(countryOrRegion);
+#endif
+        }
+
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern void XDCommonTargetCountryOrRegion(string countryOrRegion);
+#endif
+        
+        public void DisableAgreementUI()
+        {
+#if UNITY_ANDROID
+            using (var commonBridgeClass = new AndroidJavaClass(BridgeConstants.Common.SERVICE_IMPL))
+            {
+                commonBridgeClass.CallStatic("disableAgreementUI");
+            }
+#elif UNITY_IOS
+            XDCommonDisableAgreementUI();
+#endif
+        }
+
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern void XDCommonDisableAgreementUI();
+#endif
+    }
+}
+#endif

package/Runtime/Internal/Mobile/CommonFeaturesImpl.cs.meta

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

package/Runtime/Internal/Mobile/Http/CommonParamsInterceptor.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using XD.SDK.Common.Internal.Http;
+
+namespace XD.SDK.Common.Internal.Mobile
+{
+    public class CommonParamsInterceptor : HttpInterceptor
+    {
+        protected override async Task BeforeRequestAsync(IHttpRequest request, CancellationToken cancellationToken)
+        {
+            // 获取通用查询参数
+            var commonParams = XDGCommonInternal.GetCommonQueryParams(request.Host.GetHost() + request.Url, ServerTime.GetTimestamp());
+            if (commonParams != null)
+            {
+                // 合并到现有查询参数中
+                if (request.QueryParams == null)
+                {
+                    request.QueryParams = new Dictionary<string, object>();
+                }
+
+                foreach (var param in commonParams)
+                {
+                    if (!request.QueryParams.ContainsKey(param.Key))
+                    {
+                        request.QueryParams[param.Key] = param.Value;
+                    }
+                }
+            }
+
+            XDGLogger.Debug($"[CommonParamsInterceptor] commParams:{JsonConvert.SerializeObject(request.QueryParams)}");
+        }
+    }
+}

package/Runtime/Internal/Mobile/Http/CommonParamsInterceptor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2274bce9e1e242ffbb6d5cd0a270b27c
+timeCreated: 1752647002

package/Runtime/Internal/Mobile/Http.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5852630173414443ad2b879cd301873c
+timeCreated: 1752647113

package/Runtime/Internal/Mobile/XDGTool.cs

@@ -0,0 +1,51 @@
+#if UNITY_ANDROID || UNITY_IOS
+using System;
+using System.Text;
+using XD.SDK.Common.Internal.Mobile.Bridge;
+using Random = System.Random;
+
+namespace XD.SDK.Common
+{
+    public class XDGTool
+    {
+        public static bool IsEmpty(string str)
+        {
+            if (str == null)
+            {
+                return true;
+            }
+
+            if (String.IsNullOrEmpty(str))
+            {
+                return true;
+            }
+
+            if (String.IsNullOrWhiteSpace(str))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool CheckResultSuccess(Result result)
+        {
+            return result.code == Result.RESULT_SUCCESS && !string.IsNullOrEmpty(result.content);
+        }
+
+        private static string LetterStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+        public static string GetRandomStr(int length)
+        {
+            StringBuilder SB = new StringBuilder();
+            Random rd = new Random();
+            for (int i = 0; i < length; i++)
+            {
+                SB.Append(LetterStr.Substring(rd.Next(0, LetterStr.Length), 1));
+            }
+
+            return SB.ToString();
+        }
+    }
+}
+#endif

package/Runtime/Internal/Mobile/XDGTool.cs.meta

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

package/Runtime/Internal/Mobile.meta

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

package/Runtime/Internal/Standalone/Agreement/Agreement.cs

@@ -0,0 +1,78 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class Agreement {
+        [JsonProperty("agreementRegion")]
+        public string Region { get; set; }
+
+        [JsonProperty("agreementVersion")]
+        public string Version { get; set; }
+        
+        // 新协议首次签署字段
+        [JsonProperty("titleFirst")]
+        public string TitleFirst { get; set; }
+        
+        [JsonProperty("summaryFirst")]
+        public string SummaryFirst { get; set; }
+        
+        [JsonProperty("promptFirst")]
+        public string PromptFirst { get; set; }
+
+        // 新协议更新字段
+        [JsonProperty("title")]
+        public string Title { get; set; }
+        
+        [JsonProperty("summary")]
+        public string Summary { get; set; }
+        
+        [JsonProperty("prompt")]
+        public string Prompt { get; set; }
+        
+        // 按钮文案
+        [JsonProperty("agree")]
+        public string Agree { get; set; }
+        
+        [JsonProperty("disagree")]
+        public string Disagree { get; set; }
+        
+        // 勾选配置
+        [JsonProperty("options")]
+        public List<AgreementOption> Options { get; set; }
+        
+        // 韩国独有的三状态勾选
+        [JsonProperty("agreeAll")]
+        public string AgreeAll { get; set; }
+
+        // 手机和邮箱登录的协议
+        [JsonProperty("agreements")]
+        public List<XDGAgreement> Agreements { get; set; }
+        
+        [JsonIgnore]
+        public Dictionary<string, object> Extra { get; set; }
+        
+        public bool IsRegionKr()
+        {
+            return Region.ToLower().Equals("kr");
+        }
+        
+        public bool IsRegionUs()
+        {
+            return Region.ToLower().Equals("us");
+        }
+    }
+
+    public class AgreementOption
+    {
+        [JsonProperty("name")]
+        public string Name { get; set; }
+        
+        [JsonProperty("required")]
+        public bool Required { get; set; }
+        
+        [JsonProperty("title")]
+        public string Title { get; set; }
+    }
+}
+#endif

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

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