com.xd.sdk.common 0.0.2 → 0.0.11-alpha

package/Runtime/Internal/Core/ReflectionUtils.cs

@@ -0,0 +1,640 @@
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal
+{
+    /// <summary>
+    /// 反射工具类，用于在不直接依赖的情况下调用其他模块的方法
+    /// </summary>
+    public static class ReflectionUtils
+    {
+        // 缓存已查找的类型，提高性能
+        private static Dictionary<string, Type> _typeCache = new Dictionary<string, Type>();
+
+        /// <summary>
+        /// 查找一个类型
+        /// </summary>
+        /// <param name="fullTypeName">完整类型名称，包含命名空间</param>
+        /// <param name="assemblyName">程序集名称，不含.dll后缀</param>
+        /// <returns>找到的类型，未找到返回null</returns>
+        public static Type FindType(string fullTypeName, string assemblyName = null)
+        {
+            string cacheKey = assemblyName != null ? $"{fullTypeName},{assemblyName}" : fullTypeName;
+
+            // 检查缓存
+            if (_typeCache.TryGetValue(cacheKey, out Type cachedType))
+            {
+                return cachedType;
+            }
+
+            Type type = null;
+
+            try
+            {
+                // 尝试直接查找类型（如果程序集已加载）
+                if (assemblyName != null)
+                {
+                    type = Type.GetType($"{fullTypeName}, {assemblyName}");
+                }
+                else
+                {
+                    type = Type.GetType(fullTypeName);
+                }
+
+                // 如果未找到，在所有加载的程序集中查找
+                if (type == null)
+                {
+                    Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+                    foreach (Assembly assembly in assemblies)
+                    {
+                        type = assembly.GetType(fullTypeName);
+                        if (type != null)
+                        {
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"查找类型 {fullTypeName} 时出错: {ex.Message}");
+            }
+
+            // 更新缓存
+            if (type != null)
+            {
+                _typeCache[cacheKey] = type;
+            }
+
+            return type;
+        }
+
+        /// <summary>
+        /// 创建类型的实例
+        /// </summary>
+        /// <param name="type">要创建的类型</param>
+        /// <param name="parameters">构造函数参数</param>
+        /// <returns>创建的实例，失败返回null</returns>
+        public static object CreateInstance(Type type, params object[] parameters)
+        {
+            if (type == null) return null;
+
+            try
+            {
+                return Activator.CreateInstance(type, parameters);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"创建 {type.Name} 实例时出错: {ex.Message}");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// 查找并调用静态方法
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="methodName">方法名</param>
+        /// <param name="parameters">方法参数</param>
+        /// <returns>方法返回值，失败返回null</returns>
+        public static object InvokeStaticMethod(Type type, string methodName, params object[] parameters)
+        {
+            if (type == null) return null;
+
+            try
+            {
+                // 直接按方法名查找，不做复杂匹配
+                MethodInfo method = type.GetMethod(methodName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.IgnoreCase);
+
+                if (method != null)
+                {
+                    return method.Invoke(null, parameters);
+                }
+                else
+                {
+                    Debug.LogError($"找不到方法: {type.Name}.{methodName}");
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"调用 {type.Name}.{methodName} 静态方法时出错: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 调用实例方法
+        /// </summary>
+        /// <param name="instance">实例对象</param>
+        /// <param name="methodName">方法名</param>
+        /// <param name="parameters">方法参数</param>
+        /// <returns>方法返回值，失败返回null</returns>
+        public static object InvokeMethod(object instance, string methodName, params object[] parameters)
+        {
+            if (instance == null) return null;
+
+            Type type = instance.GetType();
+
+            try
+            {
+                // 直接按方法名查找，不做复杂匹配
+                MethodInfo method = type.GetMethod(methodName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase);
+
+                if (method != null)
+                {
+                    return method.Invoke(instance, parameters);
+                }
+                else
+                {
+                    Debug.LogError($"找不到方法: {type.Name}.{methodName}");
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"调用 {type.Name}.{methodName} 实例方法时出错: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 获取静态属性值
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="propertyName">属性名称</param>
+        /// <returns>属性值，失败返回null</returns>
+        public static object GetStaticProperty(Type type, string propertyName)
+        {
+            if (type == null) return null;
+
+            try
+            {
+                PropertyInfo property = type.GetProperty(propertyName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+
+                if (property != null)
+                {
+                    return property.GetValue(null);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"获取 {type.Name}.{propertyName} 静态属性时出错: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 获取静态字段值
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="fieldName">字段名称</param>
+        /// <returns>字段值，失败返回null</returns>
+        public static object GetStaticField(Type type, string fieldName)
+        {
+            if (type == null) return null;
+
+            try
+            {
+                FieldInfo field = type.GetField(fieldName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+
+                if (field != null)
+                {
+                    return field.GetValue(null);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"获取 {type.Name}.{fieldName} 静态字段时出错: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 获取实例属性值
+        /// </summary>
+        /// <param name="instance">实例对象</param>
+        /// <param name="propertyName">属性名称</param>
+        /// <returns>属性值，失败返回null</returns>
+        public static object GetProperty(object instance, string propertyName)
+        {
+            if (instance == null) return null;
+
+            Type type = instance.GetType();
+
+            try
+            {
+                PropertyInfo property = type.GetProperty(propertyName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+                if (property != null)
+                {
+                    return property.GetValue(instance);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"获取 {type.Name}.{propertyName} 实例属性时出错: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 获取实例字段值
+        /// </summary>
+        /// <param name="instance">实例对象</param>
+        /// <param name="fieldName">字段名称</param>
+        /// <returns>字段值，失败返回null</returns>
+        public static object GetField(object instance, string fieldName)
+        {
+            if (instance == null) return null;
+
+            Type type = instance.GetType();
+
+            try
+            {
+                FieldInfo field = type.GetField(fieldName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+                if (field != null)
+                {
+                    return field.GetValue(instance);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"获取 {type.Name}.{fieldName} 实例字段时出错: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 为静态属性设置值
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="propertyName">属性名称</param>
+        /// <param name="value">要设置的值</param>
+        /// <returns>是否设置成功</returns>
+        public static bool SetStaticProperty(Type type, string propertyName, object value)
+        {
+            if (type == null) return false;
+
+            try
+            {
+                PropertyInfo property = type.GetProperty(propertyName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+
+                if (property != null)
+                {
+                    property.SetValue(null, value);
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"设置 {type.Name}.{propertyName} 静态属性时出错: {ex.Message}");
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 为静态字段设置值
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="fieldName">字段名称</param>
+        /// <param name="value">要设置的值</param>
+        /// <returns>是否设置成功</returns>
+        public static bool SetStaticField(Type type, string fieldName, object value)
+        {
+            if (type == null) return false;
+
+            try
+            {
+                FieldInfo field = type.GetField(fieldName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+
+                if (field != null)
+                {
+                    field.SetValue(null, value);
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"设置 {type.Name}.{fieldName} 静态字段时出错: {ex.Message}");
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 为实例字段设置值
+        /// </summary>
+        /// <param name="instance">实例对象</param>
+        /// <param name="fieldName">字段名称</param>
+        /// <param name="value">要设置的值</param>
+        /// <returns>是否设置成功</returns>
+        public static bool SetField(object instance, string fieldName, object value)
+        {
+            if (instance == null) return false;
+
+            Type type = instance.GetType();
+
+            try
+            {
+                FieldInfo field = type.GetField(fieldName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+                if (field != null)
+                {
+                    field.SetValue(instance, value);
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"设置 {type.Name}.{fieldName} 实例字段时出错: {ex.Message}");
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 为实例属性设置值
+        /// </summary>
+        /// <param name="instance">实例对象</param>
+        /// <param name="propertyName">属性名称</param>
+        /// <param name="value">要设置的值</param>
+        /// <returns>是否设置成功</returns>
+        public static bool SetProperty(object instance, string propertyName, object value)
+        {
+            if (instance == null) return false;
+
+            Type type = instance.GetType();
+
+            try
+            {
+                PropertyInfo property = type.GetProperty(propertyName,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+                if (property != null)
+                {
+                    property.SetValue(instance, value);
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"设置 {type.Name}.{propertyName} 实例属性时出错: {ex.Message}");
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 创建一个泛型类型
+        /// </summary>
+        /// <param name="genericTypeDefinition">泛型类型定义</param>
+        /// <param name="typeArguments">泛型参数</param>
+        /// <returns>构造的泛型类型</returns>
+        public static Type MakeGenericType(Type genericTypeDefinition, params Type[] typeArguments)
+        {
+            if (genericTypeDefinition == null || !genericTypeDefinition.IsGenericTypeDefinition)
+                return null;
+
+            try
+            {
+                return genericTypeDefinition.MakeGenericType(typeArguments);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"创建泛型类型 {genericTypeDefinition.Name} 时出错: {ex.Message}");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// 创建委托
+        /// </summary>
+        /// <param name="delegateType">委托类型</param>
+        /// <param name="target">目标实例</param>
+        /// <param name="methodName">方法名</param>
+        /// <returns>创建的委托</returns>
+        public static Delegate CreateDelegate(Type delegateType, object target, string methodName)
+        {
+            if (delegateType == null || target == null) return null;
+
+            try
+            {
+                MethodInfo method = target.GetType().GetMethod(methodName,
+                    BindingFlags.Public | BindingFlags.NonPublic |
+                    BindingFlags.Instance | BindingFlags.Static);
+
+                if (method != null)
+                {
+                    return Delegate.CreateDelegate(delegateType, target, method);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"创建委托 {delegateType.Name} 指向 {target.GetType().Name}.{methodName} 时出错: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 异步调用静态方法并返回结果
+        /// </summary>
+        /// <typeparam name="T">返回值类型</typeparam>
+        /// <param name="type">类型</param>
+        /// <param name="methodName">方法名</param>
+        /// <param name="parameters">方法参数</param>
+        /// <returns>异步任务结果</returns>
+        public static async System.Threading.Tasks.Task<T> InvokeStaticMethodAsync<T>(Type type, string methodName, params object[] parameters)
+        {
+            if (type == null) return default(T);
+
+            try
+            {
+                var result = InvokeStaticMethod(type, methodName, parameters);
+                if (result is System.Threading.Tasks.Task task)
+                {
+                    await task;
+
+                    // 检查是否是 Task<T>
+                    if (task.GetType().IsGenericType)
+                    {
+                        var resultProperty = task.GetType().GetProperty("Result");
+                        if (resultProperty != null)
+                        {
+                            var taskResult = resultProperty.GetValue(task);
+                            return ConvertToType<T>(taskResult);
+                        }
+                    }
+                }
+
+                // 如果不是异步方法，直接返回结果
+                return ConvertToType<T>(result);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"异步调用 {type.Name}.{methodName} 静态方法时出错: {ex.Message}");
+                return default(T);
+            }
+        }
+
+        /// <summary>
+        /// 异步调用静态方法（无返回值）
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="methodName">方法名</param>
+        /// <param name="parameters">方法参数</param>
+        /// <returns>异步任务</returns>
+        public static async System.Threading.Tasks.Task InvokeStaticMethodAsync(Type type, string methodName, params object[] parameters)
+        {
+            if (type == null) return;
+
+            try
+            {
+                var result = InvokeStaticMethod(type, methodName, parameters);
+                if (result is System.Threading.Tasks.Task task)
+                {
+                    await task;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"异步调用 {type.Name}.{methodName} 静态方法时出错: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 异步调用实例方法并返回结果
+        /// </summary>
+        /// <typeparam name="T">返回值类型</typeparam>
+        /// <param name="instance">实例对象</param>
+        /// <param name="methodName">方法名</param>
+        /// <param name="parameters">方法参数</param>
+        /// <returns>异步任务结果</returns>
+        public static async System.Threading.Tasks.Task<T> InvokeMethodAsync<T>(object instance, string methodName, params object[] parameters)
+        {
+            if (instance == null) return default(T);
+
+            try
+            {
+                var result = InvokeMethod(instance, methodName, parameters);
+                if (result is System.Threading.Tasks.Task task)
+                {
+                    await task;
+
+                    // 检查是否是 Task<T>
+                    if (task.GetType().IsGenericType)
+                    {
+                        var resultProperty = task.GetType().GetProperty("Result");
+                        if (resultProperty != null)
+                        {
+                            var taskResult = resultProperty.GetValue(task);
+                            return ConvertToType<T>(taskResult);
+                        }
+                    }
+                }
+
+                // 如果不是异步方法，直接返回结果
+                return ConvertToType<T>(result);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"异步调用 {instance.GetType().Name}.{methodName} 实例方法时出错: {ex.Message}");
+                return default(T);
+            }
+        }
+
+        /// <summary>
+        /// 异步调用实例方法（无返回值）
+        /// </summary>
+        /// <param name="instance">实例对象</param>
+        /// <param name="methodName">方法名</param>
+        /// <param name="parameters">方法参数</param>
+        /// <returns>异步任务</returns>
+        public static async System.Threading.Tasks.Task InvokeMethodAsync(object instance, string methodName, params object[] parameters)
+        {
+            if (instance == null) return;
+
+            try
+            {
+                var result = InvokeMethod(instance, methodName, parameters);
+                if (result is System.Threading.Tasks.Task task)
+                {
+                    await task;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"异步调用 {instance.GetType().Name}.{methodName} 实例方法时出错: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 通用异步方法调用辅助方法，自动处理 Task 和 Task<T> 类型
+        /// </summary>
+        /// <param name="taskResult">方法调用返回的对象</param>
+        /// <returns>异步任务结果</returns>
+        public static async System.Threading.Tasks.Task<object> HandleAsyncResult(object taskResult)
+        {
+            if (taskResult is System.Threading.Tasks.Task task)
+            {
+                await task;
+
+                // 检查是否是 Task<T>
+                if (task.GetType().IsGenericType)
+                {
+                    var resultProperty = task.GetType().GetProperty("Result");
+                    if (resultProperty != null)
+                    {
+                        return resultProperty.GetValue(task);
+                    }
+                }
+
+                return null; // Task 类型无返回值
+            }
+
+            return taskResult; // 同步方法的直接返回值
+        }
+
+        /// <summary>
+        /// 简化的类型转换方法
+        /// </summary>
+        /// <typeparam name="T">目标类型</typeparam>
+        /// <param name="value">要转换的值</param>
+        /// <returns>转换后的值</returns>
+        private static T ConvertToType<T>(object value)
+        {
+            if (value == null)
+                return default(T);
+
+            if (value is T directMatch)
+                return directMatch;
+
+            try
+            {
+                return (T)value;
+            }
+            catch
+            {
+                return default(T);
+            }
+        }
+    }
+}

package/Runtime/Internal/Core/ReflectionUtils.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3bc624b04151420c8e71a0a7d1310aa6
+timeCreated: 1744785847

package/Runtime/Internal/Core/XDGRegionInfo.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal
+{
+    public class XDGRegionInfo
+    {
+        [JsonProperty("country_code")] public string CountryCode { get; set; }
+
+        [JsonProperty("city")] public string City { get; set; }
+
+        [JsonProperty("src_ip")] public string LocationInfoType { get; set; }
+
+        [JsonProperty("timeZone")] public string TimeZone { get; set; }
+
+        [JsonProperty("country")] public string Country { get; set; }
+
+        [JsonProperty("latitude")] public string Latitude { get; set; }
+
+        [JsonProperty("longitude")] public string Longitude { get; set; }
+
+        public XDGRegionInfo(Dictionary<string, object> dic)
+        {
+            if (dic == null) return;
+            City = XDDictionary.GetValue<string>(dic, "city");
+            CountryCode = XDDictionary.GetValue<string>(dic, "countryCode");
+            TimeZone = XDDictionary.GetValue<string>(dic, "timeZone");
+            LocationInfoType = XDDictionary.GetValue<string>(dic, "locationInfoType");
+        }
+    }
+}

package/Runtime/Internal/Core/XDGRegionInfo.cs.meta

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

package/Runtime/Internal/Core.meta

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