com.xd.sdk.common 6.29.1 → 7.0.1

package/Runtime/Internal/Standalone/UI/Controllers/XDWebViewAlert.cs

@@ -0,0 +1,246 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+using UnityEngine.UI;
+using Vuplex.WebView;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class XDWebViewAlert : UIElement
+    {
+        public const int WEB_CALLBACK = 0;
+        public const int CLOSE_CODE = -1;
+
+        private RectTransform rootRect;
+        private Image backgroundImage;
+        private CanvasWebViewPrefab canvasWebViewPrefab;
+        private Button backButton;
+        private Button closeButton;
+
+        private GameObject ErrorPanelObject;
+        private Text errorText;
+        private Button retryButton;
+        private Text retryButtonText;
+        private Coroutine closeButtonCoroutine;
+        private float timer;
+
+        public async void Reload()
+        {
+            ErrorPanelObject.SetActive(false);
+            UIManager.ShowLoading();
+
+            string url = extra["url"] as string;
+            XDGLogger.Debug($"XDWebViewAlert load url: {url}");
+            canvasWebViewPrefab.WebView.LoadUrl(url);
+
+            string jsCode = @";(function (window) {
+              window._xd_jsbridge = {
+                invoke: function (json) {
+                  try {
+                    window.vuplex.postMessage({ type: 'verify', message: json });
+                  } catch (error) {
+                    console.error('xd-jsbridge error::', error)
+                  }
+                },
+              };";
+
+            if (extra.TryGetValue("env", out var obj))
+            {
+                Dictionary<string, string> env = obj as Dictionary<string, string>;
+                if (env?.Count > 0)
+                {
+                    jsCode += "window._xd_jsbridge.env = {};\n";
+                    foreach (var kv in env)
+                    {
+                        jsCode += $"window._xd_jsbridge.env.{kv.Key} = '{kv.Value}';\n";
+                    }
+                }
+            }
+
+            jsCode += "})(window);";
+            XDGLogger.Debug($"ExecuteJavaScript: {jsCode}");
+            // 注入 js
+            _ = canvasWebViewPrefab.WebView.ExecuteJavaScript(jsCode);
+
+            await canvasWebViewPrefab.WebView.WaitForNextPageLoadToFinish();
+            UIManager.DismissLoading();
+        }
+
+        private void Awake()
+        {
+            rootRect = transform.Find("WebView").GetComponent<RectTransform>();
+            backgroundImage = transform.Find("WebView").GetComponent<Image>();
+            // canvasWebViewPrefab = transform.Find("WebView/CanvasWebViewPrefab").GetComponent<CanvasWebViewPrefab>();
+            backButton = transform.Find("WebView/BackButton").GetComponent<Button>();
+            backButton.onClick.AddListener(OnBackButtonClicked);
+            closeButton = transform.Find("WebView/CloseButton").GetComponent<Button>();
+            closeButton.onClick.AddListener(OnCloseButtonClicked);
+
+            ErrorPanelObject = transform.Find("WebView/LoadFailedView").gameObject;
+            errorText = transform.Find("WebView/LoadFailedView/ErrorText").GetComponent<Text>();
+            retryButton = transform.Find("WebView/LoadFailedView/RetryButton").GetComponent<Button>();
+            retryButtonText = transform.Find("WebView/LoadFailedView/RetryButton/Text").GetComponent<Text>();
+    
+            var webViewGameObject = Instantiate(Resources.Load(nameof(CanvasWebViewPrefab)), transform.Find("WebView/WebViewContainer"), false) as GameObject;
+            canvasWebViewPrefab = webViewGameObject?.GetComponent<CanvasWebViewPrefab>();
+                    
+            ErrorPanelObject.SetActive(false);
+            retryButton.onClick.AddListener(Reload);
+        }
+
+        private async void Start()
+        {
+            // 这里 webview 的白底会先出来然后才消失，所以取巧一下先不展示，测试可以，如果还不行的话把 visible 放到 url 成功加载之后
+            canvasWebViewPrefab.Visible = false;
+            if (extra.TryGetValue("fullScreen", out var value))
+            {
+                if (value is bool fullScreen && fullScreen)
+                {
+                    rootRect.anchorMin = Vector2.zero;
+                    rootRect.anchorMax = Vector2.one;
+                    rootRect.offsetMin = rootRect.offsetMax = Vector2.zero;
+                }
+            }
+
+            if (extra.TryGetValue("showBackButton", out var obj))
+            {
+                if (obj is bool showBackButton && !showBackButton)
+                {
+                    backButton.gameObject.SetActive(false);
+                }
+            }
+
+            if (extra.TryGetValue("showBackground", out var obj2))
+            {
+                if (obj2 is bool showBackground && !showBackground)
+                {
+                    backgroundImage.color = new Color(0.0f, 0.0f, 0.0f, 0.0f);
+                }
+            }
+
+            await canvasWebViewPrefab.WaitUntilInitialized();
+            canvasWebViewPrefab.WebView.PageLoadScripts.Add(@"
+    var styleElement = document.createElement('style');
+    styleElement.innerText = `
+      *::-webkit-scrollbar {
+        display: none;
+      }
+      * {
+        scrollbar-width: none;
+        -ms-overflow-style: none;
+      }
+    `;
+    document.head.appendChild(styleElement);
+");
+            canvasWebViewPrefab.WebView.SetDefaultBackgroundEnabled(false);
+            canvasWebViewPrefab.Visible = true;
+            canvasWebViewPrefab.WebView.UrlChanged += OnUrlChanged;
+            canvasWebViewPrefab.WebView.PageLoadFailed += OnPageLoadFailed;
+
+
+            canvasWebViewPrefab.WebView.MessageEmitted += (sender, eventArgs) =>
+            {
+                XDGLogger.Debug(eventArgs.Value);
+                Dictionary<string, string> response =
+                    JsonConvert.DeserializeObject<Dictionary<string, string>>(eventArgs.Value);
+                Dictionary<string, object> data =
+                    JsonConvert.DeserializeObject<Dictionary<string, object>>(response["message"]);
+
+                string actionName = data["name"] as string;
+                if (actionName == "action_loaded")
+                {
+                    UIManager.DismissLoading();
+                }
+                else if (actionName == "action_close")
+                {
+                    OnCloseButtonClicked();
+                }
+                else if (actionName == "action_handleCloseButton")
+                {
+                    JObject dataObj = data["data"] as JObject;
+                    if (dataObj == null)
+                    {
+                        throw new XDGError(ResponseCode.Common.Failed, "Can not find 'data' filed in js callback.");
+                    }
+
+                    bool show = dataObj["isShow"]?.Value<bool>() ?? false;
+                    float duration = dataObj["duration"]?.Value<float>() ?? 10000.0f;
+                    UpdateCloseButton(show, duration / 1000.0f);
+                }
+                else
+                {
+                    OnCallback(WEB_CALLBACK, data);
+                }
+            };
+
+            Reload();
+        }
+
+        private async void OnBackButtonClicked()
+        {
+            bool canBack = await canvasWebViewPrefab.WebView.CanGoBack();
+            if (canBack)
+            {
+                canvasWebViewPrefab.WebView.GoBack();
+            }
+            else
+            {
+                OnCallback(CLOSE_CODE, null);
+            }
+        }
+
+        private void OnCloseButtonClicked()
+        {
+            OnCallback(CLOSE_CODE, null);
+        }
+
+        void OnUrlChanged(object sender, UrlChangedEventArgs eventArgs)
+        {
+            if (Application.internetReachability == NetworkReachability.NotReachable)
+            {
+                UIManager.DismissLoading();
+                ErrorPanelObject.SetActive(true);
+            }
+            else
+            {
+                ErrorPanelObject.SetActive(false);
+            }
+        }
+
+        void OnPageLoadFailed(object sender, EventArgs eventArgs)
+        {
+            UIManager.DismissLoading();
+            ErrorPanelObject.SetActive(true);
+        }
+
+        private void UpdateCloseButton(bool show, float duration)
+        {
+            closeButton.gameObject.SetActive(show);
+            if (closeButtonCoroutine != null)
+            {
+                StopCoroutine(closeButtonCoroutine);
+            }
+
+            timer = duration;
+            closeButtonCoroutine = StartCoroutine(StartTimer());
+        }
+
+        private IEnumerator StartTimer()
+        {
+            while (timer > 0)
+            {
+                timer -= Time.deltaTime; // 减少定时器
+                yield return null; // 等待下一帧
+            }
+
+            closeButton.gameObject.SetActive(true);
+        }
+    }
+}
+
+#endif

package/Runtime/Internal/Standalone/UI/Controllers/XDWebViewAlert.cs.meta

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

package/Runtime/Internal/Standalone/UI/Controllers.meta

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

package/Runtime/Internal/Standalone/UI.meta

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

package/Runtime/Internal/Standalone/UploadConfig/UploadConfigModule.cs

@@ -0,0 +1,57 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class UploadConfigModule
+    {
+        private static bool needUploadConfig = false;
+
+        public static void TriggerUploadConfig()
+        {
+            needUploadConfig = true;
+            UIManager.ShowToast("已开启参数上报");
+        }
+
+        public static async Task TryUploadConfig()
+        {
+            if (!needUploadConfig)
+            {
+                return;
+            }
+
+            try
+            {
+                string path = "api/v1/config/upload";
+                Dictionary<string, object> xdconfigData = new Dictionary<string, object>
+                {
+                    { "app_id", ConfigModule.AppId },
+                    { "client_id", ConfigModule.ClientId },
+                    { "report_url", ConfigModule.ReportUrl },
+                    { "logout_url", ConfigModule.CancelUrl },
+                    { "region_type", ConfigModule.RegionType },
+                    { "game_name", ConfigModule.GameName },
+                    { "tapsdk", ConfigModule.TapConfig },
+                    { "apple", ConfigModule.Apple },
+                    { "google", ConfigModule.Google },
+                    { "facebook", ConfigModule.Facebook },
+                };
+                Dictionary<string, object> configData = new Dictionary<string, object>
+                {
+                    { "xdConfig", xdconfigData }
+                };
+                await XDHttpClient.Client.PostAsync<BaseResponse>(path, data: configData);
+                UIManager.ShowToast("参数上报成功");
+            }
+            catch (Exception)
+            {
+                UIManager.ShowToast("参数上报失败");
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/UploadConfig/UploadConfigModule.cs.meta

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

package/Runtime/Internal/Standalone/UploadConfig.meta

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

package/Runtime/Internal/Standalone/Utils/StandaloneDeviceInfo.cs

@@ -0,0 +1,34 @@
+using System.Globalization;
+using System;
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Runtime.InteropServices;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class StandaloneDeviceInfo {
+
+#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
+        [DllImport("MacDeviceInfo", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr GetDeviceLocation();
+
+        [DllImport("MacDeviceInfo", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr GetDeviceLanguage();
+#endif
+
+        public static string GetLocation() {
+#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
+            return Marshal.PtrToStringAnsi(GetDeviceLocation());
+#else
+        return RegionInfo.CurrentRegion.TwoLetterISORegionName;
+#endif
+        }
+
+        public static string GetLanguage() {
+#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
+            return Marshal.PtrToStringAnsi(GetDeviceLanguage());
+#else
+        return CultureInfo.CurrentUICulture.IetfLanguageTag;
+#endif
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Utils/StandaloneDeviceInfo.cs.meta

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

package/Runtime/Internal/Standalone/Utils/SteamWrapper.cs

@@ -0,0 +1,122 @@
+#if XD_STEAM_SUPPORT
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+using Steamworks;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class SteamWrapper : ISteamSDKWrapper {
+        private readonly Callback<GetAuthSessionTicketResponse_t> getAuthSessionTicketResponseCallback;
+        private readonly ConcurrentDictionary<HAuthTicket, Tuple<TaskCompletionSource<string>, string>> tickTasks;
+
+        private readonly Callback<MicroTxnAuthorizationResponse_t> mircoTxnAuthorizationCallback;
+        private readonly ConcurrentDictionary<ulong, TaskCompletionSource<string>> microTxnTasks;
+
+        public SteamWrapper() {
+            tickTasks = new ConcurrentDictionary<HAuthTicket, Tuple<TaskCompletionSource<string>, string>>();
+
+            getAuthSessionTicketResponseCallback = Callback<GetAuthSessionTicketResponse_t>.Create((GetAuthSessionTicketResponse_t pCallback) => {
+                HAuthTicket authTicket = pCallback.m_hAuthTicket;
+                if (tickTasks.TryRemove(authTicket, out Tuple<TaskCompletionSource<string>, string> callback)) {
+                    callback.Item1.TrySetResult(callback.Item2);
+                }
+            });
+
+            microTxnTasks = new ConcurrentDictionary<ulong, TaskCompletionSource<string>>();
+
+            mircoTxnAuthorizationCallback = Callback<MicroTxnAuthorizationResponse_t>.Create((MicroTxnAuthorizationResponse_t pCallback) => {
+                // 根据 pCallback.m_ulOrderID 查找对应的回调
+                ulong orderId = pCallback.m_ulOrderID;
+                UnityEngine.Debug.Log($"recv order id: {orderId}");
+                if (microTxnTasks.TryGetValue(orderId, out TaskCompletionSource<string> tcs)) {
+                    if (pCallback.m_bAuthorized == 1) {
+                        Dictionary<string, object> data = new Dictionary<string, object> {
+                            { "appId", pCallback.m_unAppID },
+                            { "orderId", pCallback.m_ulOrderID },
+                            { "authorized", pCallback.m_bAuthorized }
+                        };
+                        tcs.TrySetResult(JsonConvert.SerializeObject(data));
+                    } else {
+                        tcs.TrySetException(new XDGError(ResponseCode.Common.Failed, "Steam authorization failure"));
+                    }
+                }
+            });
+        }
+
+        public Task<string> GetAuthTicket() {
+            // if (!SteamManager.Initialized) {
+            //     throw new Exception("Steam did not initialize.");
+            // }
+
+            TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();
+
+            byte[] data = new byte[1024];
+            HAuthTicket hTicket = SteamUser.GetAuthSessionTicket(data, 1024, out uint ticketLength);
+            string ticket = BitConverter.ToString(data, 0, (int)ticketLength)
+                    .Replace("-", string.Empty);
+            tickTasks.TryAdd(hTicket, new Tuple<TaskCompletionSource<string>, string>(tcs, ticket));
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// 获取支付授权
+        /// </summary>
+        /// <param name="orderId"></param>
+        /// <returns></returns>
+        public Task<string> GetMicroTxn(ulong orderId) {
+            // if (!SteamManager.Initialized) {
+            //     throw new Exception("Steam did not initialize.");
+            // }
+
+            TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();
+            microTxnTasks.TryAdd(orderId, tcs);
+            return tcs.Task;
+        }
+
+        public string GetSteamId() {
+            // if (!SteamManager.Initialized) {
+            //     throw new Exception("Steam did not initialize.");
+            // }
+
+            try
+            {
+                CSteamID steamID = SteamUser.GetSteamID();
+                return steamID.ToString();
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error("当前开启 XD_STEAM_SUPPORT，但没有 Steam 环境");
+                return null;
+            }
+        }
+
+        public string GetSteamLanguage() {
+            // if (!SteamManager.Initialized) {
+            //     throw new Exception("Steam did not initialize.");
+            // }
+            
+            return SteamApps.GetCurrentGameLanguage();
+        }
+
+        public string GetSteamCountry() {
+            // if (!SteamManager.Initialized) {
+            //     throw new Exception("Steam did not initialize.");
+            // }
+
+            try
+            {
+                return Steamworks.SteamUtils.GetIPCountry();
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error("当前开启 XD_STEAM_SUPPORT，但没有 Steam 环境");
+                return null;
+            }
+        }
+    }
+}
+
+#endif

package/Runtime/Internal/Standalone/Utils/SteamWrapper.cs.meta

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

package/Runtime/Internal/Standalone/Utils/TaskDispatcher.cs

@@ -0,0 +1,134 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class TaskDispatcher
+    {
+        private static int _mainThreadId;
+        private static bool _initialized;
+        private static readonly Queue<Action> MainThreadActions = new Queue<Action>();
+        private static readonly object LockObj = new object();
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void Initialize()
+        {
+            // 获取Unity主线程ID
+            _mainThreadId = Thread.CurrentThread.ManagedThreadId;
+            _initialized = true;
+
+            // 创建更新钩子
+            var go = new GameObject("TaskDispatcher_MainThreadDispatcher");
+            Object.DontDestroyOnLoad(go);
+            go.AddComponent<MainThreadDispatcher>();
+        }
+
+        /// <summary>
+        /// 切换到主线程执行
+        /// </summary>
+        public static Task SwitchToMainThread(CancellationToken cancellationToken = default)
+        {
+            // 已经在主线程则直接返回完成任务
+            if (Thread.CurrentThread.ManagedThreadId == _mainThreadId)
+            {
+                return Task.CompletedTask;
+            }
+
+            var tcs = new TaskCompletionSource<bool>();
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                tcs.SetCanceled();
+                return tcs.Task;
+            }
+
+            // 注册取消回调
+            var ctr = cancellationToken.Register(() => tcs.TrySetCanceled());
+
+            // 加入主线程队列
+            lock (LockObj)
+            {
+                MainThreadActions.Enqueue(() =>
+                {
+                    ctr.Dispose();
+                    tcs.TrySetResult(true);
+                });
+            }
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// 安全地执行异步操作，避免未处理异常导致崩溃
+        /// </summary>
+        public static async void RunSafeAsync(Func<Task> action)
+        {
+            try
+            {
+                await action();
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex);
+            }
+        }
+
+        /// <summary>
+        /// 延迟指定时间后执行操作
+        /// </summary>
+        public static Task DelayedCall(int milliseconds, Action action, CancellationToken cancellationToken = default)
+        {
+            return Task.Run(async () =>
+            {
+                await Task.Delay(milliseconds, cancellationToken);
+                await SwitchToMainThread(cancellationToken);
+                action();
+            }, cancellationToken);
+        }
+
+        /// <summary>
+        /// 辅助类：主线程分发器
+        /// </summary>
+        private class MainThreadDispatcher : MonoBehaviour
+        {
+            private void Update()
+            {
+                if (!_initialized) return;
+
+                // 执行所有主线程操作
+                Action[] actionsToRun = null;
+
+                lock (LockObj)
+                {
+                    if (MainThreadActions.Count > 0)
+                    {
+                        actionsToRun = new Action[MainThreadActions.Count];
+                        MainThreadActions.CopyTo(actionsToRun, 0);
+                        MainThreadActions.Clear();
+                    }
+                }
+
+                if (actionsToRun != null)
+                {
+                    foreach (var action in actionsToRun)
+                    {
+                        try
+                        {
+                            action();
+                        }
+                        catch (Exception e)
+                        {
+                            XDGLogger.Warn(e.Message);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Utils/TaskDispatcher.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 130eae4053864ba1a4ce6e6cb5d1e518
+timeCreated: 1746674066