com.xd.sdk.account 6.29.3 → 6.31.0

package/Plugins/iOS/XDAccountSDK.framework/Headers/XDGAccountVersion.h

@@ -4,6 +4,6 @@
 //
 //  Created by Fattycat on 2023/4/14.
 //
-#define XDGAccount_VERSION @"6.29.3"
-#define XDSAccount_VERSION_CODE @"6029030"
-// HASH 6ccd542
+#define XDGAccount_VERSION @"6.31.0"
+#define XDSAccount_VERSION_CODE @"6031000"
+// HASH 13f77e9f

package/Runtime/Internal/SecurityPwd/XDGSecurityPasswordResults.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Account
+{
+    [Serializable]
+    public class XDGSecurityPasswordResponse
+    {
+        [JsonProperty("code")] public int Code { get; set; }
+        [JsonProperty("msg")] public string Msg { get; set; }
+        
+        [JsonProperty("page")] public string Page { get; set; }
+        [JsonProperty("results")] public XDGSecurityPasswordResults Results { get; set; }
+    }
+
+    [Serializable]
+    public class XDGSecurityPasswordResults
+    {
+        [JsonProperty("ticket")] public string Ticket { get; set; }
+
+        /** 操作标识：sdk_setup_security_password / action / change */
+        [JsonProperty("action")]
+        public string Action { get; set; }
+    }
+
+    public static class XDGSecurityPasswordHelper
+    {
+        internal static void HandleSecurity(Action<XDGSecurityPasswordResults, XDGError> callback, WebActionEnum webActionEnum, Dictionary<string, object> objects)
+        {
+            var resp = ParseSecurityPasswordResponse(webActionEnum, objects);
+            if (resp != null && resp.Code == 0 &&
+                resp.Results != null &&
+                !string.IsNullOrEmpty(resp.Results.Ticket) &&
+                !string.IsNullOrEmpty(resp.Results.Action))
+            {
+                callback?.Invoke(resp.Results, null);
+            }
+            else
+            {
+                var err = new XDException(resp?.Code ?? -1, resp?.Msg ?? "unknown error");
+                callback?.Invoke(null, err);
+            }
+        }
+
+        internal static XDGSecurityPasswordResponse ParseSecurityPasswordResponse(WebActionEnum actionEnum, Dictionary<string, object> properties)
+        {
+            // 关闭无参数：返回取消
+            if (properties == null)
+            {
+                if (actionEnum == WebActionEnum.CLOSE)
+                {
+                    return new XDGSecurityPasswordResponse
+                    {
+                        Code = -1,
+                        Msg = "cancel",
+                        Results = new XDGSecurityPasswordResults()
+                    };
+                }
+
+                return new XDGSecurityPasswordResponse { Results = new XDGSecurityPasswordResults() };
+            }
+
+            var normalized = new Dictionary<string, object>(properties);
+            if (normalized.TryGetValue("code", out var codeVal))
+            {
+                normalized["code"] = ToInt(codeVal);
+            }
+            if (normalized.TryGetValue("results", out var resultsVal) && resultsVal is string rs && rs.Length > 0)
+            {
+                char c = rs[0];
+                if (c == '{' || c == '[')
+                {
+                    try
+                    {
+                        var dict = JsonConvert.DeserializeObject<Dictionary<string, object>>(rs);
+                        if (dict != null)
+                        {
+                            normalized["results"] = dict;
+                        }
+                    }
+                    catch { /* 忽略并保留原值 */ }
+                }
+            }
+
+            var json = JsonConvert.SerializeObject(normalized);
+            var resp = JsonConvert.DeserializeObject<XDGSecurityPasswordResponse>(json) ?? new XDGSecurityPasswordResponse();
+            if (resp.Results == null)
+            {
+                resp.Results = new XDGSecurityPasswordResults();
+            }
+            return resp;
+        }
+
+        private static int ToInt(object value)
+        {
+            if (value == null) return 0;
+            if (value is int i) return i;
+            if (value is long l) return (int)l;
+            if (value is float f) return (int)f;
+            if (value is double d) return (int)d;
+            var s = Convert.ToString(value);
+            if (int.TryParse(s, out var iv)) return iv;
+            if (double.TryParse(s, out var dv)) return (int)dv;
+            return 0;
+        }
+    }
+}

package/Runtime/Internal/SecurityPwd/XDGSecurityPasswordResults.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 85db79b7bccf473c926ad595117425d5
+timeCreated: 1762914379

package/Runtime/Internal/SecurityPwd.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c454ff43663b4fc4853839241e0ac7a8
+timeCreated: 1762933005

package/Runtime/Internal/XDGUserCenterTracker.cs

@@ -0,0 +1 @@
+using System;
    public class XDGUserCenterTracker
    {
        public static Dictionary<string, string> SetPasswordStartProperties()
        {
            return GetCommonProperties("set_password_open");
        }
        public static Dictionary<string, string> ReSetPasswordStartProperties()
        {
            return GetCommonProperties("reset_password_open");
        }
        public static Dictionary<string, string> VerifyPasswordStartProperties()
        {
            return GetCommonProperties("verify_password_open");
        }
        private static Dictionary<string, string> GetCommonProperties(string eventName)
        {
            var eventSessionId = Guid.NewGuid().ToString();
            var utc = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
            var logid = string.Format($"{eventSessionId}{eventName}{utc}");
            return new Dictionary<string, string>
            {
                { "event_session_id", eventSessionId },
                { "tag", "usercenter" },
                { "eventName", eventName },
                { "logid", logid }
            };
        }
    }

package/Runtime/Internal/XDGUserCenterTracker.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 086994966ddb495cb0df269ff10bf8b3
+timeCreated: 1762918709

package/Runtime/XDGAccount.cs

@@ -7,35 +7,37 @@ using UnityEngine.Scripting;
 using XD.SDK.Account;
 using XD.SDK.Common;
 using XD.SDK.Account.Internal;
-
 using LoginType = XD.SDK.Account.LoginType;
 
 [assembly: Preserve]
 [assembly: AlwaysLinkAssembly]
-namespace XD.SDK.Account{
+
+namespace XD.SDK.Account
+{
     public class XDGAccount
     {
         private static IXDGAccount platformWrapper;
         public static LoginType LoginType { get; set; }
-        
-        static XDGAccount() 
+
+        static XDGAccount()
         {
             var interfaceType = typeof(IXDGAccount);
             var platformInterfaceType = AppDomain.CurrentDomain.GetAssemblies()
                 .SelectMany(assembly => assembly.GetTypes())
-                .FirstOrDefault(clazz => interfaceType.IsAssignableFrom(clazz)&& clazz.IsClass);
-            if (platformInterfaceType != null) {
+                .FirstOrDefault(clazz => interfaceType.IsAssignableFrom(clazz) && clazz.IsClass);
+            if (platformInterfaceType != null)
+            {
                 platformWrapper = Activator.CreateInstance(platformInterfaceType) as IXDGAccount;
 
                 XDAccountHttpConfig.Init();
                 UserManager.Init();
             }
-            else 
+            else
             {
                 TapLogger.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 void Login(List<LoginType> loginTypes, Action<XDGUser> callback, Action<XDGError> errorCallback)
         {
             platformWrapper.Login(loginTypes, callback, errorCallback);
@@ -56,8 +58,9 @@ namespace XD.SDK.Account{
         {
             platformWrapper.Logout();
         }
-        
-        public static void AddUserStatusChangeCallback(Action<XDGUserStatusCodeType, string> callback){
+
+        public static void AddUserStatusChangeCallback(Action<XDGUserStatusCodeType, string> callback)
+        {
             platformWrapper.AddUserStatusChangeCallback(callback);
         }
 
@@ -65,27 +68,31 @@ namespace XD.SDK.Account{
         {
             return UserManager.GetCurrentUser();
         }
-        
+
         public static void GetUser(Action<XDGUser> callback, Action<XDGError> errorCallback)
         {
             platformWrapper.GetUser(callback, errorCallback);
         }
-        
-        public static void OpenUserCenter(){
+
+        public static void OpenUserCenter()
+        {
             platformWrapper.OpenUserCenter();
         }
 
-        public static void OpenUnregister(){
+        public static void OpenUnregister()
+        {
             platformWrapper.OpenUnregister();
         }
-        
+
         //641 FB token
-        public static void IsTokenActiveWithType(LoginType loginType, Action<bool> callback){
+        public static void IsTokenActiveWithType(LoginType loginType, Action<bool> callback)
+        {
             platformWrapper.IsTokenActiveWithType(loginType, callback);
         }
-        
+
         //除了 Default 和 Guest
-        public static void BindByType(LoginType loginType, Action<bool,XDGError> callback){
+        public static void BindByType(LoginType loginType, Action<bool, XDGError> callback)
+        {
             platformWrapper.BindByType(loginType, callback);
         }
 
@@ -94,6 +101,21 @@ namespace XD.SDK.Account{
             platformWrapper.OpenUserDashboard(roleInfo);
         }
 
+        public static void SecurityPwdSetUp(Action<XDGSecurityPasswordResults, XDGError> callback)
+        {
+            XDGAccountUnified.SecurityPwdSetUp(callback);
+        }
+
+        public static void SecurityPwdAction(string action, Action<XDGSecurityPasswordResults, XDGError> callback)
+        {
+            XDGAccountUnified.SecurityPwdAction(action, callback);
+        }
+
+        public static void SecurityPwdChange(Action<bool, XDGError> callback)
+        {
+            XDGAccountUnified.SecurityPwdChange(callback);
+        }
+
         public static string GetLoginTypeString(LoginType loginType)
         {
             switch (loginType)

package/Runtime/XDGAccountUnified.cs

@@ -0,0 +1,53 @@
+using System;
+using XD.SDK.Account.Internal;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Account
+{
+    public class XDGAccountUnified
+    {
+        public static void SecurityPwdSetUp(Action<XDGSecurityPasswordResults, XDGError> callback)
+        {
+            var properties = XDGUserCenterTracker.SetPasswordStartProperties();
+            var eventUuid = XDGTracker.LogCommonEvent(properties);
+            XDGLogger.Debug($"eventUUId:{eventUuid}");
+            properties.TryGetValue("event_session_id", out var eventSessionId);
+            var host = XDConfigs.IsCN ? Constants.XD_PERSONAL_INFO_CN : Constants.XD_PERSONAL_INFO_IO;
+            var url = $"{host}/security-password/setup?xdClose=0&xdNav=0&xdBgColor=FFFFFF00&sessionUUID={eventUuid}&eventSessionId={eventSessionId}";
+            XDGCommon.OpenWebPage(url, (webActionEnum, objects) => { XDGSecurityPasswordHelper.HandleSecurity(callback, webActionEnum, objects); });
+        }
+
+        public static void SecurityPwdAction(string action, Action<XDGSecurityPasswordResults, XDGError> callback)
+        {
+            var properties = XDGUserCenterTracker.SetPasswordStartProperties();
+            var eventUuid = XDGTracker.LogCommonEvent(properties);
+            XDGLogger.Debug($"eventUUId:{eventUuid}");
+            properties.TryGetValue("event_session_id", out var eventSessionId);
+            var host = XDConfigs.IsCN ? Constants.XD_PERSONAL_INFO_CN : Constants.XD_PERSONAL_INFO_IO;
+            var url = $"{host}/security-password/verify/{action}?xdClose=0&xdNav=0&xdBgColor=FFFFFF00&sessionUUID={eventUuid}&eventSessionId={eventSessionId}";
+            XDGCommon.OpenWebPage(url, (webActionEnum, objects) => { XDGSecurityPasswordHelper.HandleSecurity(callback, webActionEnum, objects); });
+        }
+
+        public static void SecurityPwdChange(Action<bool, XDGError> callback)
+        {
+            var properties = XDGUserCenterTracker.SetPasswordStartProperties();
+            var eventUuid = XDGTracker.LogCommonEvent(properties);
+            XDGLogger.Debug($"eventUUId:{eventUuid}");
+            properties.TryGetValue("event_session_id", out var eventSessionId);
+            var host = XDConfigs.IsCN ? Constants.XD_PERSONAL_INFO_CN : Constants.XD_PERSONAL_INFO_IO;
+            var url = $"{host}/security-password/change?xdClose=0&xdNav=0&xdBgColor=FFFFFF00&sessionUUID={eventUuid}&eventSessionId={eventSessionId}";
+            XDGCommon.OpenWebPage(url, (webActionEnum, objects) =>
+            {
+                var response = XDGSecurityPasswordHelper.ParseSecurityPasswordResponse(webActionEnum, objects);
+                if (response.Code == 0)
+                {
+                    callback.Invoke(true, null);
+                    return;
+                }
+
+                callback.Invoke(false, null);
+            });
+        }
+    }
+}

package/Runtime/XDGAccountUnified.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 264b6247fd654c06acdf6e02180225e9
+timeCreated: 1762928658

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "com.xd.sdk.account",
   "displayName": "XDSDK Account",
-  "version": "6.29.3",
+  "version": "6.31.0",
   "description": "XDSDK",
   "unity": "2018.3",
   "license": "MIT",
   "dependencies": {
-    "com.xd.tds.bootstrap": "3.30.0-xd.1"
+    "com.xd.tds.bootstrap": "3.30.2-xd.1"
   }
 }