com.taptap.sdk.core 4.3.0-aplha.5

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

@@ -0,0 +1,30 @@
+using System;
+using UnityEngine;
+
+namespace TapSDK.Core.Standalone.Internal {
+
+    public static class TimeUtil
+    {
+        private static int timeOffset = 0;
+
+        private static void SetTimeOffset(int offset)
+        {
+            timeOffset = offset;
+        }
+
+        // 获取当前时间的秒级时间戳
+        public static int GetCurrentTime()
+        {
+            DateTime epochStart = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+            TimeSpan timeSpan = DateTime.UtcNow - epochStart;
+            return (int)timeSpan.TotalSeconds + timeOffset;
+        }
+
+        public static void FixTime(int time)
+        {
+            Debug.Log("FixTime called with time: " + time);
+            SetTimeOffset(time - (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds);
+        }
+    }
+
+}

package/Standalone/Runtime/Internal/Http/TimeUtil.cs.meta

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

package/Standalone/Runtime/Internal/Http.meta

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

package/Standalone/Runtime/Internal/Identity.cs

@@ -0,0 +1,43 @@
+using System;
+using UnityEngine;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class Identity {
+        public static readonly string DEVICE_ID_KEY = "tapdb_unique_id";
+        public static readonly string PERSISTENT_ID_KEY = "tapdb_persist_id";
+        public static readonly string INSTALLATION_ID_KEY = "tapdb_install_id";
+
+        public static string DeviceId {
+            get {
+                string deviceId = TapCoreStandalone.Prefs.Get<string>(DEVICE_ID_KEY);
+                if (string.IsNullOrWhiteSpace(deviceId)) {
+                    deviceId = SystemInfo.deviceUniqueIdentifier;
+                    TapCoreStandalone.Prefs.Set(DEVICE_ID_KEY, deviceId);
+                }
+                return deviceId;
+            }
+        }
+
+        public static string PersistentId {
+            get {
+                string persistentId = TapCoreStandalone.Prefs.Get<string>(PERSISTENT_ID_KEY);
+                if (string.IsNullOrWhiteSpace(persistentId)) {
+                    persistentId = Guid.NewGuid().ToString();
+                    TapCoreStandalone.Prefs.Set(PERSISTENT_ID_KEY, persistentId);
+                }
+                return persistentId;
+            }
+        }
+
+        public static string InstallationId {
+            get {
+                string installationId = TapCoreStandalone.Prefs.Get<string>(INSTALLATION_ID_KEY);
+                if (string.IsNullOrWhiteSpace(installationId)) {
+                    installationId = Guid.NewGuid().ToString();
+                    TapCoreStandalone.Prefs.Set(INSTALLATION_ID_KEY, installationId);
+                }
+                return installationId;
+            }
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal/PlayRecorder.cs

@@ -0,0 +1,53 @@
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class PlayRecorder {
+        internal static readonly string PLAYED_DURATION_KEY = "tapdb_played_duration";
+
+        /// <summary>
+        /// 记录间隔
+        /// </summary>
+        private const int RECORD_INTERVAL = 2 * 1000;
+
+        private CancellationTokenSource cts;
+
+        /// <summary>
+        /// 启动记录
+        /// </summary>
+        public async void Start() {
+            if (cts != null && !cts.IsCancellationRequested) {
+                cts.Cancel();
+            }
+            
+            cts = new CancellationTokenSource();
+            while (Application.isPlaying) {
+                try {
+                    await Task.Delay(RECORD_INTERVAL, cts.Token);
+                } catch (TaskCanceledException) {
+                    break;
+                }
+
+                // 保存用户游玩时长
+                TapCoreStandalone.Prefs.AddOrUpdate(PLAYED_DURATION_KEY,
+                    2L,
+                    (k, v) => (long)v + 2);
+            }
+        }
+
+        /// <summary>
+        /// 结束记录并上报
+        /// </summary>
+        public void Stop() {
+            cts?.Cancel();
+            if (TapCoreStandalone.Prefs.TryRemove(PLAYED_DURATION_KEY, out long duration)) {
+                Dictionary<string, object> props = new Dictionary<string, object> {
+                    { "duration", duration }
+                };
+                TapCoreStandalone.Tracker.TrackEvent("play_game", props, true);
+            }
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal/Prefs.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Linq;
+using System.IO;
+using UnityEngine;
+using TapSDK.Core;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class Prefs {
+        internal static readonly string PERSISTENT_FILE_NAME = "tapdb_storage_v2";
+
+        private string persistentFilePath;
+
+        private readonly ConcurrentDictionary<string, object> data;
+
+        private readonly Thread persistThread;
+
+        private readonly AutoResetEvent persistEvent;
+
+        public Prefs() {
+            persistentFilePath = Path.Combine(Application.persistentDataPath, PERSISTENT_FILE_NAME);
+            if (File.Exists(persistentFilePath)) {
+                try {
+                    string json = File.ReadAllText(persistentFilePath);
+                    Dictionary<string, object> jsonData = Json.Deserialize(json) as Dictionary<string, object>;
+                    ConcurrentDictionary<string, object> data = new ConcurrentDictionary<string, object>(jsonData);
+                } catch (Exception e) {
+                    TapLogger.Error(e.Message);
+                    File.Delete(persistentFilePath);
+                }
+            }
+            if (data == null) {
+                data = new ConcurrentDictionary<string, object>();
+            }
+            persistEvent = new AutoResetEvent(false);
+            persistThread = new Thread(PersistProc) {
+                IsBackground = true
+            };
+            persistThread.Start();
+        }
+
+        public T Get<T>(string key) {
+            if (data.TryGetValue(key, out object val)) {
+                return (T)val;
+            }
+            return default;
+        }
+
+        public void Set<T>(string key, T value) {
+            data[key] = value;
+            persistEvent.Set();
+        }
+
+        public bool TryRemove<T>(string key, out T val) {
+            if (data.TryRemove(key, out object v)) {
+                val = (T)v;
+                persistEvent.Set();
+                return true;
+            }
+            val = default;
+            return false;
+        }
+
+        public void AddOrUpdate(string key, object addValue, Func<string, object, object> updateValueFactory) {
+            data.AddOrUpdate(key, addValue, updateValueFactory);
+            persistEvent.Set();
+        }
+
+        private void PersistProc() {
+            while (true) {
+                persistEvent.WaitOne();
+                try {
+                    Dictionary<string, object> dict = data.ToArray()
+                        .ToDictionary(kv => kv.Key, kv => kv.Value);
+                    string json = Json.Serialize(dict);
+                    File.WriteAllText(persistentFilePath, json);
+                } catch (Exception e) {
+                    TapLogger.Error(e.Message);
+                }
+            }
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal/Tracker.cs

@@ -0,0 +1,318 @@
+using System;
+using System.Collections.Generic;
+using TapSDK.Core.Standalone;
+using System.Threading.Tasks;
+using UnityEngine;
+using TapSDK.Core.Internal.Utils;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class Tracker {
+
+        private Dictionary<string, object> customProps;
+
+        private Dictionary<string, object> basicProps;
+        private Dictionary<string, object> commonProps;
+
+        private EventSender sender;
+        private IDynamicProperties dynamicPropsDelegate;
+
+        private static string session_uuid = generateUUID();
+
+        public void Init() {
+            basicProps = new Dictionary<string, object>();
+            commonProps = new Dictionary<string, object>();
+
+            var coreOptions = TapCoreStandalone.coreOptions;
+            customProps = Json.Deserialize(coreOptions.propertiesJson) as Dictionary<string, object>;
+            sender = new EventSender();
+            
+            InitBasicProps();
+            if (TapCoreStandalone.enableAutoEvent) {
+                Dictionary<string, object> props = new Dictionary<string, object>(basicProps);
+                TrackEvent(Constants.DEVICE_LOGIN, props, true);
+            }
+        }
+
+        public void AddCommonProperty(string key, object value) {
+            commonProps[key] = value;
+        }
+
+        public void AddCommon(Dictionary<string, object> properties) {
+            foreach (KeyValuePair<string, object> kv in properties) {
+                commonProps[kv.Key] = kv.Value;
+            }
+        }
+        public void ClearCommonProperty(string key) {
+            commonProps.Remove(key);
+        }
+        public void ClearCommonProperties(string[] keys) {
+            foreach (string key in keys) {
+                commonProps.Remove(key);
+            }
+        }
+        public void ClearAllCommonProperties() {
+            commonProps.Clear();
+        }
+
+        public void RegisterDynamicPropsDelegate(IDynamicProperties dynamicPropsDelegate) {
+            this.dynamicPropsDelegate = dynamicPropsDelegate;
+        }
+
+        public void LogPurchasedEvent(string orderID, string productName, Int64 amount, string currencyType, string paymentMethod, string properties){
+            var prop = Json.Deserialize(properties) as Dictionary<string, object>;
+            
+            var data = new Dictionary<string, object> {
+                { "order_id", orderID },
+                { "product", productName },
+                { "amount", amount },
+                { "currency_type", currencyType },
+                { "payment", paymentMethod }
+            };
+            if (prop != null) {
+                foreach (KeyValuePair<string, object> kv in prop) {
+                    data[kv.Key] = kv.Value;
+                }
+            }
+            TrackEvent("charge", data);
+        }
+
+        /// <summary>
+        /// 上报事件
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="properties"></param>
+        /// <param name="isAutomationlly">是否为自动事件</param>
+        public void TrackEvent(string name, Dictionary<string, object> properties = null, bool isAutomationlly = false) {
+
+            Dictionary<string, object> props = new Dictionary<string, object>(basicProps);
+
+            if (commonProps != null) {
+                foreach (KeyValuePair<string, object> kv in commonProps) {
+                    props[kv.Key] = kv.Value;
+                }
+            }
+
+            Dictionary<string, object> dynamicProps = dynamicPropsDelegate?.GetDynamicProperties();
+            TapLogger.Debug("dynamicProps: " + dynamicProps);
+            if (dynamicProps != null) {
+                foreach (KeyValuePair<string, object> kv in dynamicProps) {
+                    props[kv.Key] = kv.Value;
+                }
+            }
+
+            if (name == Constants.DEVICE_LOGIN) { // Device login 事件带上初始化时的自定义属性
+                TapLogger.Debug("customProps: " + customProps);
+                if (customProps != null) {
+                    foreach (KeyValuePair<string, object> kv in customProps) {
+                        props[kv.Key] = kv.Value;
+                    }
+                }
+            }
+
+            props["t_log_id"] = generateUUID();
+            // 时间戳，毫秒级
+            props["timestamp"] = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+            var open_id = OpenID;
+            if (!string.IsNullOrWhiteSpace(open_id)) {
+                props["open_id"] = open_id;
+            }
+
+            TapLogger.Debug("properties: " + properties);
+            if (properties != null) {
+                foreach (KeyValuePair<string, object> kv in properties) {
+                    props[kv.Key] = kv.Value;
+                }
+            }
+
+            props["is_automatically_log"] = isAutomationlly ? "true" : "false";
+
+            var language = getServerLanguage();
+            props["sdk_locale"] = language;
+            props["lang_system"] = DeviceInfo.GetLanguage();
+
+            Dictionary<string, object> data = new Dictionary<string, object> {
+                { "client_id", TapCoreStandalone.coreOptions.clientId },
+                { "type", "track" },
+                { "name", name },
+                { "device_id", Identity.DeviceId },
+                { "properties", props },
+            };
+            if (!string.IsNullOrWhiteSpace(TapCoreStandalone.User.Id)) {
+                data["user_id"] = TapCoreStandalone.User.Id;
+            }
+
+            sender.Send(data);
+        }
+
+        /// <summary>
+        /// 上报设备属性变化
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="properties"></param>
+        public void TrackDeviceProperties(string type, Dictionary<string, object> properties) {
+            if (string.IsNullOrWhiteSpace(Identity.DeviceId)) {
+                TapLogger.Error("DeviceId is NULL.");
+                return;
+            }
+
+            Dictionary<string, object> baseProps = new Dictionary<string, object> {
+                { "device_id", Identity.DeviceId }
+            };
+            _ = TrackPropertiesAsync(type, baseProps, properties);
+        }
+
+        /// <summary>
+        /// 上报玩家属性变化
+        /// </summary>
+        public void TrackUserProperties(string type, Dictionary<string, object> properties) {
+            string userId = TapCoreStandalone.User.Id;
+            if (string.IsNullOrWhiteSpace(userId)) {
+                TapLogger.Error("UserId is NULL.");
+                return;
+            }
+
+            Dictionary<string, object> baseProps = new Dictionary<string, object> {
+                { "user_id", userId }
+            };
+            _ = TrackPropertiesAsync(type, baseProps, properties);
+        }
+
+        private Task TrackPropertiesAsync(string type,
+            Dictionary<string, object> basicProps, Dictionary<string, object> properties)
+        {
+            if (!IsInitialized) {
+                return Task.CompletedTask;
+            }
+
+            if (properties == null) {
+                properties = new Dictionary<string, object>();
+            }
+            properties["sdk_version"] = TapTapSDK.SDKVersion;
+
+            Dictionary<string, object> data = new Dictionary<string, object>(basicProps) {
+                { "client_id", TapCoreStandalone.coreOptions.clientId },
+                { "type", type },
+                { "properties", properties }
+            };
+
+            sender.Send(data);
+            return Task.CompletedTask;
+        }
+
+        private void InitBasicProps() {
+            DeviceInfo.GetMacAddress(out string macList, out string firstMac);
+            basicProps = new Dictionary<string, object> {
+                { "os", OS },
+                { "md", SystemInfo.deviceModel },
+                { "sv", SystemInfo.operatingSystem },
+                { "pn", "TapSDK" },
+                { "tapsdk_project", "TapSDKCore" },
+                { "session_uuid", session_uuid },
+                { "install_uuid", Identity.InstallationId },
+                { "persist_uuid", Identity.PersistentId },
+                { "ram", DeviceInfo.RAM },
+                { "rom", DeviceInfo.ROM },
+                { "width", Screen.currentResolution.width },
+                { "height", Screen.currentResolution.height },
+                { "provider", "unknown" },
+                { "app_version", TapCoreStandalone.coreOptions.gameVersion ?? Application.version },
+                { "sdk_version", TapTapSDK.SDKVersion },
+                { "network_type", Network },
+                { "channel", TapCoreStandalone.coreOptions.channel },
+                { "mac_list", macList },
+                { "first_mac", firstMac },
+                { "device_id5", DeviceInfo.GetLaunchUniqueID() }
+            };
+        }
+        private string OS {
+            get {
+                switch (SystemInfo.operatingSystemFamily) {
+                    case OperatingSystemFamily.Windows:
+                        return "Windows";
+                    case OperatingSystemFamily.MacOSX:
+                        return "Mac";
+                    case OperatingSystemFamily.Linux:
+                        return "Linux";
+                    default:
+                        return "Unknown";
+                }
+            }
+        }
+
+        public static string getServerLanguage() {
+            // 将 TapCoreStandalone.coreOptions.preferredLanguage 转成 zh_TW/en/zh_CN/en_GB/jp/fil 等格式
+            switch (TapCoreStandalone.coreOptions.preferredLanguage) {
+                case TapTapLanguageType.zh_Hans:
+                    return "zh_CN";
+                case TapTapLanguageType.zh_Hant:
+                    return "zh_TW";
+                case TapTapLanguageType.en:
+                    return "en_US";
+                case TapTapLanguageType.ja:
+                    return "ja_JP";
+                case TapTapLanguageType.ko:
+                    return "ko_KR";
+                case TapTapLanguageType.th:
+                    return "th_TH";
+                case TapTapLanguageType.id:
+                    return "id_ID";
+                case TapTapLanguageType.de:
+                    return "de";
+                case TapTapLanguageType.es:
+                    return "es_ES";
+                case TapTapLanguageType.fr:
+                    return "fr";
+                case TapTapLanguageType.pt:
+                    return "pt_PT";
+                case TapTapLanguageType.ru:
+                    return "ru";
+                case TapTapLanguageType.tr:
+                    return "tr";
+                case TapTapLanguageType.vi:
+                    return "vi_VN";
+                default:
+                // 默认cn返回简体中文，Overseas返回英文
+                    return TapCoreStandalone.coreOptions.region == TapTapRegionType.CN ? "zh_CN" : "en_US";
+            }
+        }
+
+        private string Network {
+            get {
+                switch (Application.internetReachability) {
+                    case NetworkReachability.ReachableViaCarrierDataNetwork:
+                        return "3";
+                    case NetworkReachability.ReachableViaLocalAreaNetwork:
+                        return "2";
+                    default:
+                        return "Unknown";
+                }
+            }
+        }
+
+        private bool IsInitialized {
+            get {
+                if (string.IsNullOrWhiteSpace(TapCoreStandalone.coreOptions.clientId)) {
+                    TapLogger.Error("MUST be initialized.");
+                    return false;
+                }
+                return true;
+            }
+        }
+
+        private static string generateUUID() {
+            return Guid.NewGuid().ToString();
+        }
+
+        private static string OpenID {
+            get {
+                IOpenIDProvider provider = BridgeUtils.CreateBridgeImplementation(typeof(IOpenIDProvider),
+                    "TapSDK.Login") as IOpenIDProvider;
+                return provider?.GetOpenID();
+            }
+        }
+
+        public interface IDynamicProperties {
+            Dictionary<string, object> GetDynamicProperties();
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal/User.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+
+namespace TapSDK.Core.Standalone.Internal {
+    public class User {
+        internal static readonly string USER_ID_KEY = "tapdb_played_duration_user_id";
+
+        internal string Id {
+            get => id;
+            set {
+                id = value;
+                TapCoreStandalone.Prefs.Set(USER_ID_KEY, id);
+            }
+        }
+
+        private string id;
+
+        private readonly PlayRecorder playRecorder;
+
+        public User() {
+            playRecorder = new PlayRecorder();
+        }
+
+        public void Login(string userId, Dictionary<string, object> props = null) {
+            // 先执行旧用户登出逻辑
+            Id = TapCoreStandalone.Prefs.Get<string>(USER_ID_KEY);
+            if (!string.IsNullOrWhiteSpace(Id)) {
+                Logout();
+            }
+
+            // 再执行新用户登录逻辑
+            Id = userId;
+
+            if (TapCoreStandalone.enableAutoEvent) {
+                TapCoreStandalone.Tracker.TrackEvent(Constants.USER_LOGIN, props, true);
+            }
+
+            Dictionary<string, object> updateProps = new Dictionary<string, object> {
+                { "has_user", true },
+            };
+            TapCoreStandalone.Tracker.TrackDeviceProperties(Constants.PROPERTY_UPDATE_TYPE, updateProps);
+
+            playRecorder.Start();
+        }
+
+        public void Logout() {
+            playRecorder.Stop();
+
+            Id = null;
+        }
+    }
+}

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

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

package/Standalone/Runtime/Internal.meta

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