com.xd.sdk.common 6.29.1 → 7.0.1

package/Runtime/Internal/Standalone/LoginTypeModel.cs.meta

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

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

@@ -0,0 +1,83 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Text;
+using System.IO;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    /// <summary>
+    /// 通用 JSON 序列化工具
+    /// </summary>
+    public class Persistence {
+        private readonly string filePath;
+
+        public Persistence(string path) {
+            filePath = path;
+        }
+
+        public async Task<T> Load<T>(string key = null) where T : class {
+            if (!File.Exists(filePath)) {
+                return null;
+            }
+
+            try {
+                string text;
+                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)) {
+                        text = EncryptionUtils.Decrypt(text, key);
+                    }
+                }
+                return JsonConvert.DeserializeObject<T>(text);
+            } catch (Exception e) {
+                XDGLogger.Warn(e.Message);
+                Delete();
+                return null;
+            }
+        }
+
+        public async Task Save<T>(T obj, string key = null) {
+            if (obj == null) {
+                XDGLogger.Warn("Saved object is null.");
+                return;
+            }
+
+            string text;
+            try {
+                text = JsonConvert.SerializeObject(obj);
+
+                if (!string.IsNullOrEmpty(key)) {
+                    text = EncryptionUtils.Encrypt(text, key);
+                }
+
+                string dirPath = Path.GetDirectoryName(filePath);
+                if (!Directory.Exists(dirPath)) {
+                    Directory.CreateDirectory(dirPath);
+                }
+
+                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;
+            }
+        }
+
+        public void Delete() {
+            if (!File.Exists(filePath)) {
+                return;
+            }
+
+            File.Delete(filePath);
+        }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/Persistence.meta

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

package/Runtime/Internal/Standalone/Phone/AreaCodeData.cs

@@ -0,0 +1,16 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone{
+    public class AreaCodeData{
+        [JsonProperty("region")]
+        public string Region { get; set; }
+        [JsonProperty("regionName")] 
+        public string RegionName { get; set; }
+        [JsonProperty("areaCode")] 
+        public string AreaCode { get; set; }
+        [JsonProperty("areaCodeName")] 
+        public string AreaCodeName { get; set; }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Phone/AreaCodeData.cs.meta

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

package/Runtime/Internal/Standalone/Phone.meta

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

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

@@ -0,0 +1,41 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    /// <summary>
+    /// Steam SDK 封装接口
+    /// </summary>
+    public interface ISteamSDKWrapper {
+        Task<string> GetAuthTicket();
+        string GetSteamId();
+        string GetSteamLanguage();
+        Task<string> GetMicroTxn(ulong orderId);
+        string GetSteamCountry();
+    }
+
+    public class SteamUtils {
+        public static ISteamSDKWrapper Instance { get; private set; }
+
+        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) {
+                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.");
+            }
+        }
+
+        /// <summary>
+        /// 是否有 SDK 支持，即 Steam 包
+        /// </summary>
+        public static bool IsSDKSupported => Instance != null;
+    }
+}
+
+#endif

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

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

package/Runtime/Internal/Standalone/Steam.meta

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

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

@@ -0,0 +1,69 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    /// <summary>
+    /// 隐私协议部分
+    /// </summary>
+    public partial class AliyunTrack
+    {
+        internal enum AgreementCountryType
+        {
+            Default = 1,
+            Korea = 2,
+            US = 3,
+        }
+
+        private static AgreementCountryType countryType;
+        private static string AgreementRegion;
+        private static string AgreementVersion;
+
+        private static string AgreementEventSessionId;
+
+        internal static string AgreementMapExtra2TrackInfo(Dictionary<string, object> extraData)
+        {
+            var extraArray = new List<string>();
+            if (countryType != AgreementCountryType.Korea) return null;
+            if (extraData == null) return null;
+            foreach (var key in extraData.Keys)
+            {
+                if (extraData[key] is bool value)
+                {
+                    extraArray.Add(key + (value ? "_enable" : "_disable"));
+                }
+            }
+            
+            return extraArray.Count > 0 ? string.Join(",", extraArray) : null;
+        }
+        
+        internal static void AgreementAsk(AgreementCountryType countryType, string region, string version)
+        {
+            AliyunTrack.countryType = countryType;
+            AgreementRegion = region;
+            AgreementVersion = version;
+            AgreementEventSessionId = GetNewEventSessionId();
+            LogEventAsync("sdkprotocol_privacy_ask", GetAgreementModuleCommonProperties("sdkprotocol_privacy_ask"));
+        }
+        
+        internal static void AgreementSign(string extras = "")
+        {
+            var contents = GetAgreementModuleCommonProperties("sdkprotocol_privacy_agree");
+            contents["extras"] = extras;
+            LogEventAsync("sdkprotocol_privacy_agree", contents);
+
+        }
+        
+        private static Dictionary<string, string> GetAgreementModuleCommonProperties(string eventName)
+        {
+            var content = new Dictionary<string, string>();
+            content["tag"] = "sdkprotocol";
+            content["event_session_id"] = AgreementEventSessionId;
+            content["popup_type"] = ((int)countryType).ToString();
+            content["a_region"] = AgreementRegion;
+            content["a_version"] = AgreementVersion;
+            content["logid"] = GetLogId(AgreementEventSessionId, eventName);
+            return content;
+        }
+    }
+}
+#endif

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

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

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

@@ -0,0 +1,382 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Reflection;
+using Newtonsoft.Json;
+using UnityEngine;
+using XD.SDK.Common.Internal.Events;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class AliyunTrackBadResponse
+    {
+        [JsonProperty("errorCode")] public string errorCode { get; private set; }
+
+        [JsonProperty("errorMessage")] public string errorMessage { get; private set; }
+    }
+
+    public class AliyunTrackRequest
+    {
+        [JsonProperty("__logs__")] public Dictionary<string, string>[] content { get; set; }
+    }
+
+    public partial class AliyunTrack
+    {
+        private static readonly string GlobalTrackHost = "https://event-tracking-global.ap-southeast-1.log.aliyuncs.com";
+        private static readonly string ChinaTrackHost = "https://event-tracking-cn.cn-beijing.log.aliyuncs.com";
+
+        private static readonly string TestLogStoreUrl = "logstores/sdk6-test/track";
+        private static readonly string FormalLogStoreUrl = "logstores/sdk6-prod/track";
+
+        // 首次打开时间戳 key
+        private const string FIRST_OPEN_KEY = "unity_pc_first_open_timestamp";
+        private const string CREATE_TIME_KEY = "unity_create_time";
+        private static string FirstOpenTimestamp { get; set; }
+        private static DateTime UtcTime => new DateTime(1970, 1, 1);
+
+        private static bool isGolbal;
+
+        // 是否为测试服,否则为正式服
+        private static bool isDevServer;
+
+        private static Dictionary<string, object> Headers =>
+            new Dictionary<string, object>()
+            {
+                ["x-log-apiversion"] = "0.6.0",
+            };
+
+        public static string TrackUrl
+        {
+            get => (isGolbal ? GlobalTrackHost : ChinaTrackHost) + "/" + (isDevServer ? TestLogStoreUrl : FormalLogStoreUrl);
+        }
+
+        private static Dictionary<string, string> content = new Dictionary<string, string>();
+
+        private static Dictionary<string, string>[] contents = new Dictionary<string, string>[1] { content };
+
+        private static List<AliyunTrackRequest> requestList = new List<AliyunTrackRequest>();
+
+        private static bool startSending;
+
+        private static long EventIndex = 1;
+
+        /// <summary>
+        /// 每次启动更新一次 session_uuid
+        /// </summary>
+        public static string CurrentSessionUUId { get; private set; }
+
+        private static long GetUtcTimeStamp()
+        {
+            return new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
+        }
+
+        public static string GetNewEventSessionId()
+        {
+            return Guid.NewGuid().ToString();
+        }
+
+        public static void Init()
+        {
+            CurrentSessionUUId = Guid.NewGuid().ToString();
+            isGolbal = ConfigModule.IsGlobal;
+            CheckFirstOpen();
+        }
+
+        private static void CheckFirstOpen()
+        {
+            if (IsFirstOpen(out string createTime))
+            {
+                RecordFirstOpen(createTime);
+            }
+            else
+            {
+                FirstOpenTimestamp = PlayerPrefs.GetString(FIRST_OPEN_KEY);
+            }
+        }
+
+        private static bool IsFirstOpen(out string createTimeString)
+        {
+            var isFirstOpen = false;
+            var createTimeRecord = PlayerPrefs.GetString(CREATE_TIME_KEY, "");
+            var createTimeCurrent = (long)GetRootFolderInfo().CreationTimeUtc.Subtract(UtcTime).TotalSeconds;
+            createTimeString = createTimeCurrent.ToString();
+
+            if (createTimeRecord != createTimeString)
+                isFirstOpen = true;
+
+            return isFirstOpen;
+        }
+
+        private static DirectoryInfo GetRootFolderInfo()
+        {
+            return new DirectoryInfo(Application.dataPath);
+        }
+
+        private static void RecordFirstOpen(string createTimeCurrentStr)
+        {
+            var firstOpenTime = (long)DateTime.UtcNow.Subtract(UtcTime).TotalMilliseconds;
+            FirstOpenTimestamp = firstOpenTime.ToString();
+            PlayerPrefs.SetString(FIRST_OPEN_KEY, FirstOpenTimestamp);
+            PlayerPrefs.SetString(CREATE_TIME_KEY, createTimeCurrentStr);
+        }
+
+        public static string GetLogId(string eventSessionId, string eventName)
+        {
+            return string.Format($"{eventSessionId}{eventName}{GetUtcTimeStamp()}");
+        }
+
+        private static bool SignedAgreementValid()
+        {
+            return AgreementModule.SignedAgreementValid;
+        }
+
+        private static void RefreshPresetPropertiesAsync()
+        {
+            RefreshStaticPresetProperties();
+            var userAgreeGetDeviceInfo = SignedAgreementValid();
+            if (userAgreeGetDeviceInfo)
+                RefreshDeviceInfos();
+        }
+
+        private static void RefreshStaticPresetProperties()
+        {
+            content["channel"] = ConfigModule.Channel;
+            content["session_uuid"] = CurrentSessionUUId;
+            content["app_version"] = Application.version;
+            content["sdk_version"] = XDGConstants.SDK_VERSION;
+            content["xd_client_id"] = ConfigModule.ClientId;
+            content["source"] = "client";
+            content["os"] = GetPlatform();
+            content["game_first_open_timestamp"] = FirstOpenTimestamp;
+        }
+
+        public static string GetPlatform()
+        {
+            string os = "Linux";
+#if UNITY_STANDALONE_OSX
+            os = "MacOS";
+#elif UNITY_STANDALONE_WIN
+            os = "Windows";
+#elif UNITY_ANDROID
+            os = "Android";
+#elif UNITY_IOS
+            os = "iOS";
+#endif
+            return os;
+        }
+
+        private static void RefreshDeviceInfos()
+        {
+            content["device_id"] = SystemInfo.deviceUniqueIdentifier;
+            content["os_version"] = SystemInfo.operatingSystem;
+            content["brand"] = SystemInfo.deviceModel;
+            content["model"] = SystemInfo.processorType;
+        }
+
+        private static void RefreshCommonPropertiesAsync()
+        {
+            content["event_index"] = EventIndex.ToString();
+            EventIndex++;
+            content["time"] = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds() + "";
+            if (SignedAgreementValid())
+            {
+                content["orientation"] = "unknown";
+                var orientationString = Screen.orientation.ToString().ToLower();
+                if (orientationString.Contains("protrait"))
+                    content["orientation"] = "protrait";
+                else if (orientationString.Contains("landscape"))
+                    content["orientation"] = "landscape";
+                content["width"] = Screen.currentResolution.width.ToString();
+                content["height"] = Screen.currentResolution.height.ToString();
+                content["lang"] = StandaloneDeviceInfo.GetLanguage();
+                content["loc"] = StandaloneDeviceInfo.GetLocation();
+
+                var isInit = XDGCommon.IsInitialized();
+                if (!isInit) return;
+
+                content["device_id_in_db"] = DeviceIdInDB == null ? string.Empty : DeviceIdInDB;
+
+                var user = XDGEventBus.Publish<XDGUser>(XDGEvents.AccountGetCurrentUser);
+                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();
+            }
+            else
+            {
+                content["orientation"] = "";
+                content["width"] = "";
+                content["height"] = "";
+                content["lang"] = "";
+                content["account"] = "";
+                if (!content.ContainsKey("isLoginModule") || content["isLoginModule"] != "true")
+                    content["login_type"] = "";
+            }
+        }
+
+        public static void LogEventAsync(string eventName, Dictionary<string, string> contents)
+        {
+            try
+            {
+                content.Clear();
+                if (contents != null)
+                {
+                    foreach (var kv in contents)
+                    {
+                        content[kv.Key] = kv.Value;
+                    }
+                }
+
+                content["name"] = eventName;
+                RefreshPresetPropertiesAsync();
+                RefreshCommonPropertiesAsync();
+                TrackAsync();
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn($"[XD::LogEventAsync] TrackAsync Event Error! Message: {e.Message}\n{e.StackTrace}");
+            }
+        }
+
+        private static async Task SendTrackInfo()
+        {
+            startSending = true;
+            while (true)
+            {
+                if (requestList.Count > 0)
+                {
+                    var request = requestList[0];
+                    try
+                    {
+                        var responseMessage = await TrackHttpClient.Request(TrackUrl, HttpMethod.Post, Headers, request);
+                        if (!responseMessage.IsSuccessStatusCode)
+                        {
+                            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}"));
+                        }
+
+                        responseMessage.Dispose();
+                        requestList.RemoveAt(0);
+                    }
+                    catch (Exception e)
+                    {
+                        XDGLogger.Warn(string.Format($"[XD::TrackAsync] request failed! Message: {e.Message}\n {e.StackTrace}"));
+                        requestList.RemoveAt(0);
+                    }
+                }
+                else
+                {
+                    await Task.Delay(100);
+                }
+            }
+        }
+
+        private static void TrackAsync()
+        {
+            var tempDic = new List<Dictionary<string, string>>();
+            foreach (var ct in contents)
+            {
+                var infoStr = JsonConvert.SerializeObject(ct);
+                tempDic.Add(new Dictionary<string, string>()
+                {
+                    { "content", infoStr }
+                });
+            }
+
+            var request = new AliyunTrackRequest()
+            {
+                content = tempDic.ToArray(),
+            };
+
+            ProcessContents(request);
+            DebugContentsInfo();
+
+            requestList.Add(request);
+            if (!startSending)
+                _ = SendTrackInfo();
+        }
+
+        private static void ProcessContents(AliyunTrackRequest requestContent)
+        {
+            if (requestContent != null)
+            {
+                var nullKeys = new HashSet<string>();
+                foreach (var dic in requestContent.content)
+                {
+                    nullKeys.Clear();
+                    foreach (var kv in dic)
+                    {
+                        if (dic[kv.Key] == null)
+                            nullKeys.Add(kv.Key);
+                    }
+
+                    foreach (var nullKey in nullKeys)
+                    {
+                        dic[nullKey] = "null";
+                    }
+                }
+            }
+        }
+
+        [Conditional("UNITY_EDITOR")]
+        private static void DebugContentsInfo()
+        {
+            var sb = new StringBuilder();
+            if (contents != null)
+            {
+                foreach (var dic in contents)
+                {
+                    foreach (var kv in dic)
+                    {
+                        sb.Append($"{kv.Key} : {kv.Value}\n");
+                    }
+                }
+            }
+
+            try
+            {
+                XDGLogger.Warn($"TrackAsync Info:\n{sb}");
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error($"{e.Message}\n{e.StackTrace}");
+            }
+        }
+
+        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);
+    }
+}
+
+#endif