com.xd.sdk.account 6.29.1 → 7.0.1

package/Runtime/Internal/Standalone/Auth/SteamAuth.cs

@@ -0,0 +1,90 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class SteamAuth : WebAuth
+    {
+        static readonly List<HttpListener> servers = new List<HttpListener>();
+
+        internal static async Task<Dictionary<string, object>> GetAuthData()
+        {
+            if (SteamUtils.IsSDKSupported)
+            {
+                // 先尝试从 Steam SDK 中获取 auth data
+                Dictionary<string, object> authData = await GetAuthDataFromSDK();
+                return authData;
+            }
+
+            // 返回 Web 授权的 AuthData
+            Dictionary<string, object> queryParams = new Dictionary<string, object>
+            {
+                { "auth_type", "steam" },
+                { "state", LocalServerUtils.GenerateRandomDataBase64url(32) },
+                { "console_type", "steam" },
+            };
+            return await StartListener(servers, LoginType.Steam, queryParams);
+        }
+
+        public static async Task<Dictionary<string, object>> GetAuthDataFromSDK()
+        {
+            // 返回 SDK 授权的 AuthData
+            // 登陆跳转授权 Track
+            AliyunTrack.LoginAuthorize();
+            try
+            {
+                string ticket = await SteamUtils.Instance.GetAuthTicket();
+                if (string.IsNullOrWhiteSpace(ticket))
+                {
+                    // 登陆授权失败
+                    AliyunTrack.LoginAuthorizeFail("SteamNoTicket");
+                }
+                else
+                {
+                    // 登陆授权成功
+                    AliyunTrack.LoginAuthorizeSuccess();
+                }
+
+                return new Dictionary<string, object>
+                {
+                    { "type", (int)LoginType.Steam },
+                    { "token", ticket }
+                };
+            }
+            catch (Exception e)
+            {
+                // 登陆授权成功
+                AliyunTrack.LoginAuthorizeFail($"SteamNoTicket {e.Message}");
+                return new Dictionary<string, object>
+                {
+                    { "type", (int)LoginType.Steam },
+                    { "token", null }
+                };
+            }
+        }
+
+        public static string GetSteamIdFromSDK()
+        {
+            return SteamUtils.Instance.GetSteamId();
+        }
+
+        public static Dictionary<string, object> GetCacheData()
+        {
+            if (!SteamUtils.IsSDKSupported)
+            {
+                return null;
+            }
+
+            return new Dictionary<string, object>
+            {
+                { "steamId", GetSteamIdFromSDK() }
+            };
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Auth/SteamAuth.cs.meta

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

package/Runtime/Internal/Standalone/Auth/TapAuth.cs

@@ -0,0 +1,72 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Events;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    internal class TapAuth
+    {
+        internal static async Task<Dictionary<string, object>> GetAuthData()
+        {
+            return await RequestTapToken();
+        }
+
+        private static async Task<Dictionary<string, object>> RequestTapToken()
+        {
+            try
+            {
+                AliyunTrack.LoginAuthorize();
+
+                if (ConfigModule.TapConfig != null && ConfigModule.UsingTapPC)
+                {
+                    UIManager.ShowLoading(timeout: 3);
+                }
+                // 使用明确指定参数类型的反射调用
+                var permissions = ConfigModule.TapConfig.Permissions;
+                var authData = await XDGEventBus.PublishAsync<Dictionary<string, object>>(XDGEvents.TapSDKLogin, permissions);
+
+                // 检查返回结果是否为 null
+                if (authData == null)
+                {
+                    throw new XDGError(ResponseCode.Common.Failed, "TapTap 登录返回数据为空");
+                }
+
+                authData.Add("type", (int)LoginType.TapTap);
+                authData.Add("scope", string.Join(",", permissions?.ToArray()));
+                
+                if (ConfigModule.TapConfig != null && ConfigModule.UsingTapPC)
+                {
+                    UIManager.DismissLoading();
+                }
+                AliyunTrack.LoginAuthorizeSuccess();
+                return authData;
+            }
+            // catch (TapException e)
+            // {
+            //     if (e.code == (int)TapErrorCode.ERROR_CODE_LOGIN_CANCEL)
+            //     {
+            //         XDGLogger.Debug($"Tap 取消登录，{e}");
+            //         AliyunTrack.LoginAuthorizeFail(e.Message);
+            //         throw XDGErrorExtensions.CancelledError(e.message);
+            //     }
+            //     else
+            //     {
+            //         XDGLogger.Warn($"Tap 登录失败：{e}");
+            //         throw new XDGError(ResponseCode.Common.Failed, e.Message);
+            //     }
+            // }
+            catch (Exception e)
+            {
+                AliyunTrack.LoginAuthorizeFail(e.Message);
+                XDGLogger.Warn($"Tap 登录失败：{e}");
+                throw new XDGError(ResponseCode.Common.Failed, e.Message);
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Auth/TapAuth.cs.meta

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

package/Runtime/Internal/Standalone/Auth/WebAuth.cs

@@ -0,0 +1,144 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using UnityEngine;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Standalone;
+using CommonTrack = XD.SDK.Common.Internal.Standalone.AliyunTrack;
+
+namespace XD.SDK.Account.Internal.Standalone
+{
+    public class WebAuth
+    {
+        protected static async Task<Dictionary<string, object>> StartListener(List<HttpListener> servers,
+            LoginType loginType,
+            Dictionary<string, object> queryParams)
+        {
+            string redirectUri = $"http://{IPAddress.Loopback}:{LocalServerUtils.GetRandomUnusedPort()}";
+            string gameName = ConfigModule.GameName;
+            string lang = XDLocalization.GetLanguageKey();
+
+            string url = ConfigModule.IsGlobal ? AuthConstants.GLOBAL_AUTH_HOST : AuthConstants.CN_AUTH_HOST;
+            Dictionary<string, object> queryParameters = new Dictionary<string, object>
+            {
+                { "redirect_uri", redirectUri },
+                { "game_name", gameName },
+                { "lang", lang },
+
+                { "eventSessionId", AliyunTrack.LoginEventSessionId },
+                { "app_version", Application.version },
+                { "brand", SystemInfo.deviceModel },
+                { "channel", ConfigModule.Channel },
+                { "device_id", SystemInfo.deviceUniqueIdentifier },
+                { "isloginmodule", true },
+                { "loc", StandaloneDeviceInfo.GetLocation() },
+                { "model", SystemInfo.processorType },
+                { "orientation", Screen.orientation.ToString().ToLower() },
+                { "session_uuid", CommonTrack.CurrentSessionUUId },
+                { "xd_client_id", ConfigModule.ClientId },
+                { "sdk_version", XDGConstants.SDK_VERSION },
+                { "os", CommonTrack.GetPlatform() },
+                { "os_version", SystemInfo.operatingSystem }
+            };
+            if (queryParams != null)
+            {
+                foreach (KeyValuePair<string, object> kv in queryParams)
+                {
+                    queryParameters[kv.Key] = kv.Value;
+                }
+            }
+
+            IEnumerable<string> queryPairs = queryParameters.Select(kv => $"{kv.Key}={kv.Value}");
+            string authRequest = $"{url}?{string.Join("&", queryPairs)}";
+
+            // 弹出授权页
+            XDGLogger.Debug($"auth: {authRequest}");
+            AliyunTrack.LoginAuthorize();
+            // 登陆跳转授权 Track
+            Application.OpenURL(Uri.EscapeUriString(authRequest));
+
+            // 启动监听
+            HttpListener server = new HttpListener();
+            server.Prefixes.Add($"{redirectUri}/");
+            server.Start();
+
+            servers.Add(server);
+
+            Dictionary<string, object> authData = new Dictionary<string, object>
+            {
+                { "type", (int)loginType }
+            };
+
+            while (true)
+            {
+                try
+                {
+                    HttpListenerContext context = await server.GetContextAsync();
+
+                    XDGLogger.Debug($"Request url: {context.Request.RawUrl}");
+                    XDGLogger.Debug($"Request method: {context.Request.HttpMethod}");
+
+                    context.Response.StatusCode = 200;
+                    context.Response.Close();
+
+                    if (context.Request.HttpMethod == "OPTIONS")
+                    {
+                        continue;
+                    }
+
+                    foreach (HttpListener svr in servers)
+                    {
+                        svr.Stop();
+                    }
+
+                    servers.Clear();
+
+                    // 解析 Web 像 SDK 传递的参数
+                    string[] urlSegments = context.Request.RawUrl.Split('?');
+                    if (urlSegments.Length < 2)
+                    {
+                        return new Dictionary<string, object>();
+                    }
+
+                    string queryString = urlSegments[1];
+                    string[] queries = queryString.Split('&');
+
+                    foreach (string query in queries)
+                    {
+                        if (string.IsNullOrEmpty(query))
+                        {
+                            continue;
+                        }
+
+                        string[] kv = query.Split('=');
+                        if (kv.Length < 2)
+                        {
+                            continue;
+                        }
+
+                        authData[kv[0]] = kv[1];
+                    }
+
+                    // 登陆授权成功
+                    AliyunTrack.LoginAuthorizeSuccess();
+                    return authData;
+                }
+                catch (Exception e)
+                {
+                    XDGLogger.Debug(e.Message);
+                    // 异常结果则一直 pending
+                    // 登陆授权失败
+                    AliyunTrack.LoginAuthorizeFail(e.Message);
+                    TaskCompletionSource<Dictionary<string, object>> tcs =
+                        new TaskCompletionSource<Dictionary<string, object>>();
+                    return await tcs.Task;
+                }
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Auth/WebAuth.cs.meta

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

package/Runtime/Internal/Standalone/Auth.meta

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

package/Runtime/Internal/Standalone/Compliance/XDComplianceCode.cs

@@ -0,0 +1,15 @@
+namespace XD.SDK.Account.Standalone
+{
+    public enum XDComplianceCode
+    {
+        LoginSuccess = 500,
+        Exited = 1000,
+        SwitchAccount = 1001,
+        PeriodRestrict = 1030,
+        DurationLimit = 1050,
+        AgeLimit = 1100,
+        InvalidClientOrNetworkError = 1200,
+        RealNameStop = 9002
+    }
+
+}

package/Runtime/Internal/Standalone/Compliance/XDComplianceCode.cs.meta

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

package/Runtime/Internal/Standalone/Compliance.meta

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