com.xd.sdk.common 7.1.2 → 7.2.1-alpha

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/CommonFeaturesImpl.cs

@@ -195,10 +195,10 @@ namespace XD.SDK.Common.Internal.Standalone
 
                 isInited = true;
             }
-            catch (Exception e)
+            catch (Exception)
             {
                 isInited = false;
-                throw e;
+                throw;
             }
             finally
             {

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;
             }
         }