com.xd.sdk.common 7.1.2 → 7.2.0

package/Resources/Shaders/UI/UI_Default-Gamma.mat

@@ -0,0 +1,36 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: UI_Default-Gamma
+  m_Shader: {fileID: 4800000, guid: 09659b2e9120d6a4490f5e5a7f7619c0, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _ColorMask: 15
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UseUIAlphaClip: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []

package/Resources/Shaders/UI/UI_Default-Gamma.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cb7e1a0e9ae57274b80858a808d7c9ba
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Resources/Shaders/UI/UI_Default-Mask.mat

@@ -0,0 +1,36 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: UI_Default-Mask
+  m_Shader: {fileID: 4800000, guid: 09659b2e9120d6a4490f5e5a7f7619c0, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _ColorMask: 15
+    - _Stencil: 1
+    - _StencilComp: 8
+    - _StencilOp: 3
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UseUIAlphaClip: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []

package/Resources/Shaders/UI/UI_Default-Mask.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a950954ffa1698d4094aaf27b366d2b1
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Resources/Shaders/UI.meta

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

package/Resources/Shaders.meta

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

package/Runtime/Internal/Events/XDGEventBus.cs

@@ -2,9 +2,90 @@ using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using UnityEngine;
+using XD.SDK.Common;
 
 namespace XD.SDK.Common.Internal.Events
 {
+    /// <summary>
+    /// 事件执行结果包装类，使用 XDGError 统一封装错误信息。
+    /// </summary>
+    /// <typeparam name="T">返回值类型</typeparam>
+    public class EventResult<T>
+    {
+        public bool IsSuccess { get; private set; }
+
+        public T Value { get; private set; }
+
+        /// <summary>
+        /// 业务错误信息（包含错误码、错误文案等）。
+        /// </summary>
+        public XDGError Error { get; private set; }
+
+        public string ErrorMessage
+        {
+            get { return Error != null ? Error.ErrorMsg : null; }
+        }
+
+        private EventResult(bool isSuccess, T value, XDGError error)
+        {
+            IsSuccess = isSuccess;
+            Value = value;
+            Error = error;
+        }
+
+        public static EventResult<T> Success(T value)
+        {
+            return new EventResult<T>(true, value, null);
+        }
+
+        public static EventResult<T> Failure(XDGError error)
+        {
+            return new EventResult<T>(false, default(T), error);
+        }
+
+        public static EventResult<T> Failure(Exception exception)
+        {
+            if (exception is XDGError xdError)
+            {
+                return Failure(xdError);
+            }
+
+            // 非 XDGError 的异常，统一包装成一个 UnknownError，detail 中保留原始异常信息
+            var wrapped = new XDGError(
+                code: ResponseCode.Common.Failed,
+                errorMsg: exception != null ? exception.Message : "Unknown error",
+                detail: exception != null ? exception.ToString() : null);
+
+            return Failure(wrapped);
+        }
+
+        public static EventResult<T> Failure(string errorMessage)
+        {
+            return Failure(new XDGError(errorMessage));
+        }
+
+        /// <summary>
+        /// 获取值，如果失败则抛出 XDGError。
+        /// </summary>
+        public T GetValueOrThrow()
+        {
+            if (!IsSuccess)
+            {
+                throw Error ?? new XDGError("Event execution failed.");
+            }
+
+            return Value;
+        }
+
+        /// <summary>
+        /// 获取值，如果失败则返回默认值。
+        /// </summary>
+        public T GetValueOrDefault(T defaultValue = default(T))
+        {
+            return IsSuccess ? Value : defaultValue;
+        }
+    }
+
     public static class XDGEventBus
     {
         private static readonly Dictionary<string, List<Func<object[], object>>> SyncHandlers = new Dictionary<string, List<Func<object[], object>>>();
@@ -31,29 +112,50 @@ namespace XD.SDK.Common.Internal.Events
             });
         }
 
-        public static T Publish<T>(string eventName, params object[] args)
+        /// <summary>
+        /// 发布带返回值的同步事件，直接返回 EventResult（破坏性变更：原来返回 T）。
+        /// </summary>
+        public static EventResult<T> Publish<T>(string eventName, params object[] args)
         {
             if (SyncHandlers.TryGetValue(eventName, out var handlers) && handlers.Count > 0)
             {
                 try
                 {
                     var result = handlers[0](args);
-                    return result is T ? (T)result : default(T);
+                    var typedResult = result is T ? (T)result : default(T);
+                    return EventResult<T>.Success(typedResult);
                 }
                 catch (Exception ex)
                 {
-                    XDGLogger.Error($"[XDEventBus] Error publishing sync event {eventName}: {ex.Message}", XDGLoggerTag.Common);
-                    return default(T);
+                    XDGLogger.Error($"[XDEventBus] Error publishing sync event {eventName}: {ex}", XDGLoggerTag.Common);
+                    return EventResult<T>.Failure(ex);
                 }
             }
 
             XDGLogger.Debug($"[XDEventBus] No handler found for sync event: {eventName}", XDGLoggerTag.Common);
-            return default(T);
+            return EventResult<T>.Failure($"No handler found for event: {eventName}");
         }
 
+        /// <summary>
+        /// 发布不关心返回值的同步事件，保持原有 fire-and-forget 行为。
+        /// </summary>
         public static void Publish(string eventName, params object[] args)
         {
-            Publish<object>(eventName, args);
+            if (SyncHandlers.TryGetValue(eventName, out var handlers) && handlers.Count > 0)
+            {
+                try
+                {
+                    handlers[0](args);
+                }
+                catch (Exception ex)
+                {
+                    XDGLogger.Error($"[XDEventBus] Error publishing sync event {eventName}: {ex}", XDGLoggerTag.Common);
+                }
+            }
+            else
+            {
+                XDGLogger.Debug($"[XDEventBus] No handler found for sync event: {eventName}", XDGLoggerTag.Common);
+            }
         }
 
         #endregion
@@ -78,30 +180,50 @@ namespace XD.SDK.Common.Internal.Events
             });
         }
 
-        public static async Task<T> PublishAsync<T>(string eventName, params object[] args)
+        /// <summary>
+        /// 发布带返回值的异步事件，直接返回 EventResult（破坏性变更：原来返回 Task&lt;T&gt;）。
+        /// </summary>
+        public static async Task<EventResult<T>> PublishAsync<T>(string eventName, params object[] args)
         {
             if (AsyncHandlers.TryGetValue(eventName, out var handlers) && handlers.Count > 0)
             {
                 try
                 {
                     var result = await handlers[0](args);
-                    XDGLogger.Debug($"[XDEventBus] publishing async event {eventName}, result: {result}", XDGLoggerTag.Common);
-                    return result is T ? (T)result : default(T);
+                    var typedResult = result is T ? (T)result : default(T);
+                    return EventResult<T>.Success(typedResult);
                 }
                 catch (Exception ex)
                 {
-                    XDGLogger.Error($"[XDEventBus] Error publishing async event {eventName}: {ex.Message}", XDGLoggerTag.Common);
-                    return default(T);
+                    XDGLogger.Warn($"[XDEventBus] Error publishing async event {eventName}: {ex}", XDGLoggerTag.Common);
+                    return EventResult<T>.Failure(ex);
                 }
             }
 
             XDGLogger.Debug($"[XDEventBus] No handler found for async event: {eventName}", XDGLoggerTag.Common);
-            return default(T);
+            return EventResult<T>.Failure($"No handler found for event: {eventName}");
         }
 
+        /// <summary>
+        /// 发布不关心返回值的异步事件，保持原有 fire-and-forget 行为。
+        /// </summary>
         public static async Task PublishAsync(string eventName, params object[] args)
         {
-            await PublishAsync<object>(eventName, args);
+            if (AsyncHandlers.TryGetValue(eventName, out var handlers) && handlers.Count > 0)
+            {
+                try
+                {
+                    await handlers[0](args);
+                }
+                catch (Exception ex)
+                {
+                    XDGLogger.Error($"[XDEventBus] Error publishing async event {eventName}: {ex}", XDGLoggerTag.Common);
+                }
+            }
+            else
+            {
+                XDGLogger.Debug($"[XDEventBus] No handler found for async event: {eventName}", XDGLoggerTag.Common);
+            }
         }
 
         #endregion

package/Runtime/Internal/Standalone/Http/Interceptor/MacAuthenticationInterceptor.cs

@@ -36,12 +36,12 @@ namespace XD.SDK.Common.Internal.Standalone.Http.Interceptor
         {
             try
             {
-                var accessToken = await XDGEventBus.PublishAsync<XDGAccessToken>(XDGEvents.AccountGetAccessToken);
+                var accessTokenResult = await XDGEventBus.PublishAsync<XDGAccessToken>(XDGEvents.AccountGetAccessToken);
+                var accessToken = accessTokenResult.GetValueOrThrow();
                 if (accessToken == null)
                 {
                     return null;
                 }
-
                 var uri = new Uri(url);
                 var timeStr = ServerTime.GetTimestamp();
                 var nonce = GetRandomStr(5);
@@ -57,9 +57,9 @@ namespace XD.SDK.Common.Internal.Standalone.Http.Interceptor
                 XDGLogger.Debug($"generate MAC token: {authToken}", XDGLoggerTag.Http);
                 return authToken;
             }
-            catch (Exception ex)
+            catch (XDGError ex)
             {
-                XDGLogger.Error($"Failed to generate MAC token: {ex.Message}", XDGLoggerTag.Http);
+                XDGLogger.Error($"Failed to generate MAC token: {ex.ErrorMsg}", XDGLoggerTag.Http);
                 return null;
             }
         }

package/Runtime/Internal/Standalone/Track/AliyunTrack.cs

@@ -199,14 +199,18 @@ namespace XD.SDK.Common.Internal.Standalone
                 var isInit = XDGCommon.IsInitialized();
                 if (!isInit) return;
 
-                content["device_id_in_db"] = DeviceIdInDB == null ? string.Empty : DeviceIdInDB;
+                content["device_id_in_db"] = DeviceIdInDB() == null ? string.Empty : DeviceIdInDB();
 
-                var user = XDGEventBus.Publish<XDGUser>(XDGEvents.AccountGetCurrentUser);
-                if (user == null) return;
+                var userResult = XDGEventBus.Publish<XDGUser>(XDGEvents.AccountGetCurrentUser);
+                var user = userResult.GetValueOrDefault();
+                if (user == null)
+                {
+                    return;
+                }
 
                 content["account"] = user.UserId;
                 if (!content.ContainsKey("isLoginModule") || content["isLoginModule"] != "true")
-                    content["login_type"] = !string.IsNullOrEmpty(user.LoginTypeName) ? user.LoginTypeName : user.GetLoginType().ToString();
+                    content["login_type"] = !string.IsNullOrEmpty(userResult.Value.LoginTypeName) ? userResult.Value.LoginTypeName : userResult.Value.GetLoginType().ToString();
             }
             else
             {
@@ -351,31 +355,34 @@ namespace XD.SDK.Common.Internal.Standalone
             }
         }
 
-        private static string DeviceIdInDB =>
-            // Type TapDBType = typeof(TapDB);
-            // FieldInfo dbField = TapDBType.GetField("db", BindingFlags.Static | BindingFlags.NonPublic);
-            // object db = dbField.GetValue(null);
-            //
-            // Type dbType = db.GetType();
-            // FieldInfo identityField = dbType.GetField("Identity", BindingFlags.Static | BindingFlags.NonPublic);
-            // object identity = identityField.GetValue(null);
-            //
-            // if (identity == null)
-            // {
-            //     return null;
-            // }
-            //
-            // Type identityType = identity.GetType();
-            // PropertyInfo deviceIdProperty = identityType.GetProperty("DeviceId");
-            // object deviceId = deviceIdProperty.GetValue(identity);
-            //
-            // if (deviceId == null)
-            // {
-            //     return null;
-            // }
-            //
-            // return deviceId as string;
-            XDGEventBus.Publish<string>(XDGEvents.TapSDKGetDeviceID);
+        private static string DeviceIdInDB()
+        {
+            var deviceResult = XDGEventBus.Publish<string>(XDGEvents.TapSDKGetDeviceID);
+            return deviceResult.GetValueOrDefault();
+        }
+        // Type TapDBType = typeof(TapDB);
+        // FieldInfo dbField = TapDBType.GetField("db", BindingFlags.Static | BindingFlags.NonPublic);
+        // object db = dbField.GetValue(null);
+        //
+        // Type dbType = db.GetType();
+        // FieldInfo identityField = dbType.GetField("Identity", BindingFlags.Static | BindingFlags.NonPublic);
+        // object identity = identityField.GetValue(null);
+        //
+        // if (identity == null)
+        // {
+        //     return null;
+        // }
+        //
+        // Type identityType = identity.GetType();
+        // PropertyInfo deviceIdProperty = identityType.GetProperty("DeviceId");
+        // object deviceId = deviceIdProperty.GetValue(identity);
+        //
+        // if (deviceId == null)
+        // {
+        //     return null;
+        // }
+        //
+        // return deviceId as string;
     }
 }
 

package/Runtime/Internal/Standalone/UI/Base/UIManager.cs

@@ -137,7 +137,6 @@ namespace XD.SDK.Common.Internal.Standalone
                     managerObject.AddComponent<ContainerWindow>();
 
                     instance.mask = managerObject.transform.Find("Background").gameObject;
-
                     instance.windowStack = managerObject.transform.Find("WindowStack");
 
                     instance.toast = managerObject.transform.Find("Toast").gameObject;
@@ -198,6 +197,7 @@ namespace XD.SDK.Common.Internal.Standalone
             if (uiElements.Count == 0)
             {
                 XDGLogger.Debug("没有 UIElement 子类可处理.", XDGLoggerTag.Common);
+                UpdateMask();
             }
             else
             {

package/Runtime/Internal/Standalone/UI/Base/XDGCommonUIResources.cs

@@ -0,0 +1,107 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    /// <summary>
+    /// 提供 Common 模块内部统一使用的 UI 材质访问接口。
+    /// 默认会优先根据当前 ColorSpace 选择对应的材质，如果找不到 Linear 版本则回退到 Gamma 版本。
+    /// 实际材质文件放在任意包的 Resources/Shaders/UI 目录下即可（例如 Common 或 BuildTools），
+    /// 但路径必须保持与常量中定义的一致。
+    /// </summary>
+    public static class XDGCommonUIResources
+    {
+        // 贴图渲染用的默认 UI 材质
+        private const string SpriteGammaPath = "Shaders/UI/UI_Default-Gamma";
+        private const string SpriteLinearPath = "Shaders/UI/UI_Default-Linear";
+
+        // 蒙版用的默认 UI 材质
+        private const string MaskGammaPath = "Shaders/UI/UI_Default-Mask";
+        private const string MaskLinearPath = "Shaders/UI/UI_Default-Mask-Linear";
+
+        private static Material spriteGamma;
+        private static Material spriteLinear;
+
+        private static Material maskGamma;
+        private static Material maskLinear;
+
+        /// <summary>
+        /// 获取当前 ColorSpace 下推荐使用的 UI Sprite 材质。
+        /// </summary>
+        public static Material GetDefaultSpriteMaterial()
+        {
+            if (QualitySettings.activeColorSpace == ColorSpace.Linear)
+            {
+                if (spriteLinear == null)
+                {
+                    spriteLinear = LoadMaterialWithFallback(SpriteLinearPath, SpriteGammaPath, "Sprite Linear");
+                }
+
+                if (spriteLinear != null)
+                {
+                    return spriteLinear;
+                }
+            }
+
+            if (spriteGamma == null)
+            {
+                spriteGamma = LoadMaterial(SpriteGammaPath, "Sprite Gamma");
+            }
+
+            return spriteGamma;
+        }
+
+        /// <summary>
+        /// 获取当前 ColorSpace 下推荐使用的 UI Mask 材质。
+        /// </summary>
+        internal static Material GetDefaultMaskMaterial()
+        {
+            if (QualitySettings.activeColorSpace == ColorSpace.Linear)
+            {
+                if (maskLinear == null)
+                {
+                    maskLinear = LoadMaterialWithFallback(MaskLinearPath, MaskGammaPath, "Mask Linear");
+                }
+
+                if (maskLinear != null)
+                {
+                    return maskLinear;
+                }
+            }
+
+            if (maskGamma == null)
+            {
+                maskGamma = LoadMaterial(MaskGammaPath, "Mask Gamma");
+            }
+
+            return maskGamma;
+        }
+
+        private static Material LoadMaterialWithFallback(string primaryPath, string fallbackPath, string label)
+        {
+            Material material = LoadMaterial(primaryPath, label);
+            if (material != null)
+            {
+                return material;
+            }
+
+            return LoadMaterial(fallbackPath, label + " Fallback");
+        }
+
+        private static Material LoadMaterial(string path, string label)
+        {
+            Material material = Resources.Load<Material>(path);
+            if (material == null)
+            {
+                Debug.LogWarning(
+                    "[XDGCommonUIResources] 未找到 UI 材质: \"" + label +
+                    "\"，Resources 路径: \"" + path + "\"");
+            }
+
+            return material;
+        }
+    }
+}
+#endif
+
+

package/Runtime/Internal/Standalone/UI/Base/XDGCommonUIResources.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/CloseWebFunction.cs

@@ -16,7 +16,16 @@ namespace XD.SDK.Common.Internal.Standalone
         {
             XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}", XDGLoggerTag.Web);
             var dic = JsonConvert.DeserializeObject<Dictionary<string, object>>(data);
-            UIManager.Dismiss();
+            if (webView?.ProviderWebView()?.Url != null)
+            {
+                var url = webView?.ProviderWebView()?.Url;
+                var queryParams = WebRequest.ParseQueryString(url);
+                var noUI = WebRequest.GetValueOrDefault(queryParams, "xdNoUI", "0") == "1";
+                if (!noUI)
+                {
+                    UIManager.Dismiss();
+                }
+            }
             webView?.ProviderWebTrans()?.TransObserver(WebActionEnum.CLOSE, dic);
             webView?.Release();
         }

package/Runtime/Internal/Standalone/Web/WebRequest.cs

@@ -81,7 +81,7 @@ namespace XD.SDK.Common.Internal.Standalone
             return dic;
         }
 
-        internal static TValue GetValueOrDefault<TKey, TValue>(
+        public static TValue GetValueOrDefault<TKey, TValue>(
             Dictionary<TKey, TValue> dictionary,
             TKey key,
             TValue defaultValue)

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "com.xd.sdk.common",
   "displayName": "XDGSDK Common",
-  "version": "7.1.2",
+  "version": "7.2.0",
   "description": "XDGSDK",
   "unity": "2019.3",
   "license": "MIT",
   "dependencies": {
-    "com.xd.sdk.foundation": "7.1.2"
+    "com.xd.sdk.foundation": "7.2.0"
   }
 }