com.xd.sdk.common 7.1.1 → 7.2.0

package/Runtime/Internal/Standalone/Http/XDHttpUtils.cs

@@ -3,54 +3,77 @@ using System.Linq;
 using System.Text;
 using System.Net.Http;
 
-namespace XD.SDK.Common.Internal.Standalone {
-    public class XDHttpUtils {
-        public static void PrintRequest(HttpClient client, HttpRequestMessage request, string content = null) {
-            if (XDGLogger.LogDelegate == null) {
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class XDHttpUtils
+    {
+        public static void PrintRequest(HttpClient client, HttpRequestMessage request, string content = null)
+        {
+            if (XDGLogger.LogDelegate == null)
+            {
                 return;
             }
-            if (client == null) {
+
+            if (client == null)
+            {
                 return;
             }
-            if (request == null) {
+
+            if (request == null)
+            {
                 return;
             }
+
             StringBuilder sb = new StringBuilder();
             sb.AppendLine("=== HTTP Request Start ===");
             sb.AppendLine($"URL: {request.RequestUri}");
             sb.AppendLine($"Method: {request.Method}");
             sb.AppendLine($"Headers: ");
-            foreach (var header in client.DefaultRequestHeaders) {
+            foreach (var header in client.DefaultRequestHeaders)
+            {
                 sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
             }
-            foreach (var header in request.Headers) {
+
+            foreach (var header in request.Headers)
+            {
                 sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
             }
-            if (request.Content != null) {
-                foreach (var header in request.Content.Headers) {
+
+            if (request.Content != null)
+            {
+                foreach (var header in request.Content.Headers)
+                {
                     sb.AppendLine($"\t{header.Key}: {string.Join(",", header.Value.ToArray())}");
                 }
             }
-            if (!string.IsNullOrEmpty(content)) {
+
+            if (!string.IsNullOrEmpty(content))
+            {
                 sb.AppendLine($"Content: {content}");
             }
+
             sb.AppendLine("=== HTTP Request End ===");
-            XDGLogger.Debug(sb.ToString());
+            XDGLogger.Debug(sb.ToString(), XDGLoggerTag.Http);
         }
 
-        public static void PrintResponse(HttpResponseMessage response, string content = null) {
-            if (XDGLogger.LogDelegate == null) {
+        public static void PrintResponse(HttpResponseMessage response, string content = null)
+        {
+            if (XDGLogger.LogDelegate == null)
+            {
                 return;
             }
+
             StringBuilder sb = new StringBuilder();
             sb.AppendLine("=== HTTP Response Start ===");
             sb.AppendLine($"URL: {response.RequestMessage.RequestUri}");
             sb.AppendLine($"Status Code: {response.StatusCode}");
-            if (!string.IsNullOrEmpty(content)) {
+            if (!string.IsNullOrEmpty(content))
+            {
                 sb.AppendLine($"Content: {content}");
             }
+
             sb.AppendLine("=== HTTP Response End ===");
-            XDGLogger.Debug(sb.ToString());
+            XDGLogger.Debug(sb.ToString(), XDGLoggerTag.Http);
         }
     }
 }

package/Runtime/Internal/Standalone/IPInfo/IPInfoModule.cs

@@ -7,8 +7,10 @@ using System.Net.Http.Headers;
 using UnityEngine;
 using Newtonsoft.Json;
 
-namespace XD.SDK.Common.Internal.Standalone {
-    public class IPInfoModule {
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class IPInfoModule
+    {
         //IP信息
         private readonly static string IP_INFO = "https://ip.xindong.com/myloc2";
 
@@ -20,63 +22,83 @@ namespace XD.SDK.Common.Internal.Standalone {
 
         private static HttpClient client;
 
-       public static HttpClient Client {
-            get {
-                if (client == null) {
+        public static HttpClient Client
+        {
+            get
+            {
+                if (client == null)
+                {
                     client = new HttpClient();
                     client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                     client.Timeout = TimeSpan.FromSeconds(3);
                 }
+
                 return client;
             }
         }
 
-       public static async Task SaveToLocal(XDGRegionInfo xdgRegionInfo) {
+        public static async Task SaveToLocal(XDGRegionInfo xdgRegionInfo)
+        {
             await persistence.Save(xdgRegionInfo);
             local = xdgRegionInfo;
         }
 
-       public static async Task<XDGRegionInfo> GetLocalIPInfo() {
-            if (local == null) {
+        public static async Task<XDGRegionInfo> GetLocalIPInfo()
+        {
+            if (local == null)
+            {
                 local = await persistence.Load<XDGRegionInfo>();
             }
+
             return local;
         }
 
-       public static XDGRegionInfo GetCachedIPInfo(){
+        public static XDGRegionInfo GetCachedIPInfo()
+        {
             return local;
         }
 
-       public static async Task<XDGRegionInfo> RequestIpInfo() {
-            try {
+        public static async Task<XDGRegionInfo> RequestIpInfo()
+        {
+            try
+            {
                 HttpResponseMessage response = await Client.GetAsync(IP_INFO);
                 string resultString = await response.Content.ReadAsStringAsync();
-                if (response.IsSuccessStatusCode) {
+                if (response.IsSuccessStatusCode)
+                {
                     XDGRegionInfo ret = JsonConvert.DeserializeObject<XDGRegionInfo>(resultString);
                     return ret;
                 }
+
                 throw new XDGError((int)response.StatusCode, resultString);
-            } catch (Exception e) {
-                XDGLogger.Warn($"Request IP info error: {e}");
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn($"Request IP info error: {e}", XDGLoggerTag.Http);
                 throw e;
             }
         }
 
-       public static async Task<XDGRegionInfo> GetIpInfo() {
-            try {
+        public static async Task<XDGRegionInfo> GetIpInfo()
+        {
+            try
+            {
                 XDGRegionInfo xdgRegionInfo = await RequestIpInfo();
                 return xdgRegionInfo;
-            } catch (Exception e) {
-                XDGLogger.Warn($"Get IP error: {e}");
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn($"Get IP error: {e}", XDGLoggerTag.Http);
                 XDGRegionInfo xdgRegionInfo = await IPInfoModule.GetLocalIPInfo();
                 return xdgRegionInfo;
             }
         }
 
-       public static async void RequestIpInfoAndSave(){
+        public static async void RequestIpInfoAndSave()
+        {
             XDGRegionInfo xdgRegionInfo = await GetIpInfo();
             await SaveToLocal(xdgRegionInfo);
         }
     }
 }
-#endif
+#endif

package/Runtime/Internal/Standalone/IPInfo/XDGAreaCode.cs

@@ -36,7 +36,7 @@ namespace XD.SDK.Common.Internal.Standalone
             }
             catch (Exception e)
             {
-                XDGLogger.Warn($"拉取区号列表失败: {e}");
+                XDGLogger.Warn($"拉取区号列表失败: {e}", XDGLoggerTag.Common);
                 var areaCodesStorage = await persistence.Load<List<AreaCodeData>>();
                 if (areaCodesStorage?.Count > 0)
                 {

package/Runtime/Internal/Standalone/Persistence/Persistence.cs

@@ -7,72 +7,92 @@ using Newtonsoft.Json;
 using XD.SDK.Common;
 using XD.SDK.Common.Internal;
 
-namespace XD.SDK.Common.Internal.Standalone {
+namespace XD.SDK.Common.Internal.Standalone
+{
     /// <summary>
     /// 通用 JSON 序列化工具
     /// </summary>
-    public class Persistence {
+    public class Persistence
+    {
         private readonly string filePath;
 
-        public Persistence(string path) {
+        public Persistence(string path)
+        {
             filePath = path;
         }
 
-        public async Task<T> Load<T>(string key = null) where T : class {
-            if (!File.Exists(filePath)) {
+        public async Task<T> Load<T>(string key = null) where T : class
+        {
+            if (!File.Exists(filePath))
+            {
                 return null;
             }
 
-            try {
+            try
+            {
                 string text;
-                using (FileStream fs = File.OpenRead(filePath)) {
+                using (FileStream fs = File.OpenRead(filePath))
+                {
                     byte[] buffer = new byte[fs.Length];
                     await fs.ReadAsync(buffer, 0, (int)fs.Length);
                     text = Encoding.UTF8.GetString(buffer);
 
-                    if (!string.IsNullOrEmpty(key)) {
+                    if (!string.IsNullOrEmpty(key))
+                    {
                         text = EncryptionUtils.Decrypt(text, key);
                     }
                 }
+
                 return JsonConvert.DeserializeObject<T>(text);
-            } catch (Exception e) {
-                XDGLogger.Warn(e.Message);
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn(e.Message, XDGLoggerTag.Common);
                 Delete();
                 return null;
             }
         }
 
-        public async Task Save<T>(T obj, string key = null) {
-            if (obj == null) {
-                XDGLogger.Warn("Saved object is null.");
+        public async Task Save<T>(T obj, string key = null)
+        {
+            if (obj == null)
+            {
+                XDGLogger.Warn("Saved object is null.", XDGLoggerTag.Common);
                 return;
             }
 
             string text;
-            try {
+            try
+            {
                 text = JsonConvert.SerializeObject(obj);
 
-                if (!string.IsNullOrEmpty(key)) {
+                if (!string.IsNullOrEmpty(key))
+                {
                     text = EncryptionUtils.Encrypt(text, key);
                 }
 
                 string dirPath = Path.GetDirectoryName(filePath);
-                if (!Directory.Exists(dirPath)) {
+                if (!Directory.Exists(dirPath))
+                {
                     Directory.CreateDirectory(dirPath);
                 }
 
-                using (FileStream fs = File.Create(filePath)) {
+                using (FileStream fs = File.Create(filePath))
+                {
                     byte[] buffer = Encoding.UTF8.GetBytes(text);
                     await fs.WriteAsync(buffer, 0, buffer.Length);
                 }
-            } catch (Exception e) {
-                XDGLogger.Warn(e.Message);
-                return;
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error(e, XDGLoggerTag.Common);
             }
         }
 
-        public void Delete() {
-            if (!File.Exists(filePath)) {
+        public void Delete()
+        {
+            if (!File.Exists(filePath))
+            {
                 return;
             }
 

package/Runtime/Internal/Standalone/Steam/SteamUtils.cs

@@ -4,11 +4,13 @@ using System.Linq;
 using System.Threading.Tasks;
 using UnityEngine;
 
-namespace XD.SDK.Common.Internal.Standalone {
+namespace XD.SDK.Common.Internal.Standalone
+{
     /// <summary>
     /// Steam SDK 封装接口
     /// </summary>
-    public interface ISteamSDKWrapper {
+    public interface ISteamSDKWrapper
+    {
         Task<string> GetAuthTicket();
         string GetSteamId();
         string GetSteamLanguage();
@@ -16,18 +18,23 @@ namespace XD.SDK.Common.Internal.Standalone {
         string GetSteamCountry();
     }
 
-    public class SteamUtils {
+    public class SteamUtils
+    {
         public static ISteamSDKWrapper Instance { get; private set; }
 
-        static SteamUtils() {
+        static SteamUtils()
+        {
             Type interfaceType = typeof(ISteamSDKWrapper);
             Type steamWrapperType = AppDomain.CurrentDomain.GetAssemblies()
                 .SelectMany(assembly => assembly.GetTypes())
                 .FirstOrDefault(clazz => interfaceType.IsAssignableFrom(clazz) && clazz.IsClass);
-            if (steamWrapperType != null) {
+            if (steamWrapperType != null)
+            {
                 Instance = Activator.CreateInstance(steamWrapperType) as ISteamSDKWrapper;
-            } else {
-                XDGLogger.Warn($"No class implements {interfaceType} Type. Current Platform: {Application.platform}, if you are using Editor, please check if you have installed XDSDK pc module.");
+            }
+            else
+            {
+                XDGLogger.Warn($"No class implements {interfaceType} Type. Current Platform: {Application.platform}, if you are using Editor, please check if you have installed XDSDK pc module.", XDGLoggerTag.Common);
             }
         }
 

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
             {
@@ -240,7 +244,7 @@ namespace XD.SDK.Common.Internal.Standalone
             }
             catch (Exception e)
             {
-                XDGLogger.Warn($"[XD::LogEventAsync] TrackAsync Event Error! Message: {e.Message}\n{e.StackTrace}");
+                XDGLogger.Warn($"[XD::LogEventAsync] TrackAsync Event Error! Message: {e.Message}\n{e.StackTrace}", XDGLoggerTag.Track);
             }
         }
 
@@ -260,7 +264,7 @@ namespace XD.SDK.Common.Internal.Standalone
                             string resultString = await responseMessage.Content.ReadAsStringAsync();
                             var badResponse = JsonConvert.DeserializeObject<AliyunTrackBadResponse>(resultString);
                             XDGLogger.Warn(string.Format(
-                                $"[XD::TrackAsync] request failed! \n statusCode: {responseMessage.StatusCode} errorCode : {badResponse?.errorCode} errorMessage : {badResponse?.errorMessage}"));
+                                $"[XD::TrackAsync] request failed! \n statusCode: {responseMessage.StatusCode} errorCode : {badResponse?.errorCode} errorMessage : {badResponse?.errorMessage}"), XDGLoggerTag.Track);
                         }
 
                         responseMessage.Dispose();
@@ -268,7 +272,7 @@ namespace XD.SDK.Common.Internal.Standalone
                     }
                     catch (Exception e)
                     {
-                        XDGLogger.Warn(string.Format($"[XD::TrackAsync] request failed! Message: {e.Message}\n {e.StackTrace}"));
+                        XDGLogger.Warn(string.Format($"[XD::TrackAsync] request failed! Message: {e.Message}\n {e.StackTrace}"), XDGLoggerTag.Track);
                         requestList.RemoveAt(0);
                     }
                 }
@@ -343,39 +347,42 @@ namespace XD.SDK.Common.Internal.Standalone
 
             try
             {
-                XDGLogger.Warn($"TrackAsync Info:\n{sb}");
+                XDGLogger.Warn($"TrackAsync Info:\n{sb}", XDGLoggerTag.Track);
             }
             catch (Exception e)
             {
-                XDGLogger.Error($"{e.Message}\n{e.StackTrace}");
+                XDGLogger.Error($"{e.Message}\n{e.StackTrace}", XDGLoggerTag.Track);
             }
         }
 
-        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

@@ -86,6 +86,7 @@ namespace XD.SDK.Common.Internal.Standalone
                 Instance.StopCoroutine(Instance.loadingTimeoutCoroutine);
                 Instance.loadingTimeoutCoroutine = null;
             }
+
             Instance.loading.transform.SetAsLastSibling();
             Instance.loading.SetActive(true);
             Instance.UpdateMask();
@@ -136,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;
@@ -163,7 +163,7 @@ namespace XD.SDK.Common.Internal.Standalone
             GameObject gameObj = Instantiate(Resources.Load("Prefabs/" + prefabName)) as GameObject;
             if (gameObj == null)
             {
-                XDGLogger.Debug("没找到 prefab named： \"" + prefabName + "\"");
+                XDGLogger.Debug("没找到 prefab named： \"" + prefabName + "\"", XDGLoggerTag.Common);
                 return null;
             }
             else
@@ -196,7 +196,8 @@ namespace XD.SDK.Common.Internal.Standalone
         {
             if (uiElements.Count == 0)
             {
-                XDGLogger.Debug("没有 UIElement 子类可处理.");
+                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: