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

package/Runtime/Internal/Standalone/Common/User32.cs.meta

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

package/Runtime/Internal/Standalone/Common/WindowUtils.cs

@@ -0,0 +1,17 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class WindowUtils {
+        public static void BringToFront() {
+#if UNITY_EDITOR
+            Debug.LogWarning("Unsupport bring to front on Unity Editor.");
+// #elif UNITY_STANDALONE_OSX
+            Application.OpenURL($"open-taptap-{ConfigModule.TapConfig.ClientId}://");
+#elif UNITY_STANDALONE_WIN
+            User32.ForceWindowIntoForeground();
+#endif
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Common/WindowUtils.cs.meta

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

package/Runtime/Internal/Standalone/Common.meta

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

package/Runtime/Internal/Standalone/CommonFeaturesImpl.cs

@@ -0,0 +1,256 @@
+#if UNITY_STANDALONE || UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using UnityEngine;
+using Vuplex.WebView;
+using XD.SDK.Common.Internal.Events;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class CommonFeaturesImpl : IXDGCommonExtended
+    {
+        private static CommonFeaturesImpl _instance;
+
+        private static readonly object LockObj = new object();
+
+        public static CommonFeaturesImpl Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (LockObj)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = new CommonFeaturesImpl();
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        private CommonFeaturesImpl()
+        {
+        }
+
+        private bool isIniting;
+        private bool isInited;
+
+        public async void InitSDK(XDGInitParam param, Action<bool, string> callback)
+        {
+            try
+            {
+                await Init(param);
+                callback?.Invoke(true, "XDSDK Init OK");
+            }
+            catch (Exception e)
+            {
+                callback?.Invoke(false, $"XDSDK Init Error! Message: {e.Message}\n{e.StackTrace}");
+            }
+        }
+
+        public bool IsInitialized()
+        {
+            return isInited;
+        }
+
+        public void SetLanguage(LangType langType)
+        {
+            XDLocalization.CurrentLang = langType;
+        }
+
+        public void StoreReview()
+        {
+            XDGLogger.Warn("Standalone not support StoreReview");
+        }
+
+        public void TrackUser(string userId)
+        {
+            if (!ConfigModule.TapConfig.TrackOnRoleId)
+            {
+                XDGEventBus.Publish(XDGEvents.TapSDKSetUserID, userId);
+            }
+        }
+
+        public void TrackRole(XDGRoleInfo role)
+        {
+            XDGEventBus.Publish(XDGEvents.TapSDKTrackRole, ConfigModule.TapConfig.TrackOnRoleId, JsonConvert.SerializeObject(role));
+        }
+
+        public void TrackEvent(string eventName, Dictionary<string, object> properties = null)
+        {
+            XDGEventBus.Publish(XDGEvents.TapSDKTrackEvent, eventName, JsonConvert.SerializeObject(properties));
+        }
+
+        public void PreloadWebPage(string url)
+        {
+            WebRequest.Preload(url);
+        }
+
+        public void OpenWebPage(string url, Action<WebActionEnum, Dictionary<string, object>> callback)
+        {
+            WebRequest.OpenWebPage(url, callback);
+        }
+
+        public void DisableAgreementUI()
+        {
+            AgreementModule.DisableAgreement = true;
+        }
+
+        public bool IsCn()
+        {
+            return !ConfigModule.IsGlobal;
+        }
+
+        public Dictionary<string, string> GetCommonQueryParams(string url, long timestamp)
+        {
+            var clientId = ConfigModule.ClientId;
+            var param = new Dictionary<string, string>
+            {
+                { "clientId", string.IsNullOrEmpty(clientId) ? "" : clientId },
+                { "appId", ConfigModule.AppId == null ? "" : ConfigModule.AppId },
+                { "did", SystemInfo.deviceUniqueIdentifier },
+                { "sdkLang", XDLocalization.GetLanguageKey() },
+                { "time", $"{timestamp}" },
+                { "chn", "PC" },
+                { "locationInfoType", "ip" },
+                { "mem", SystemInfo.systemMemorySize / 1024 + "GB" },
+                { "res", Screen.width + "_" + Screen.height },
+                { "mod", SystemInfo.deviceModel },
+                { "sdkVer", XDGConstants.SDK_VERSION },
+                { "pkgName", Application.identifier },
+                { "brand", SystemInfo.deviceModel },
+                { "os", SystemInfo.operatingSystem },
+                { "pt", XDUtility.GetPlatform() },
+                { "appVer", Application.version },
+                { "appVerCode", Application.version },
+                { "cpu", SystemInfo.processorType },
+                { "lang", StandaloneDeviceInfo.GetLanguage() },
+                { "loc", StandaloneDeviceInfo.GetLocation() }
+            };
+            if (!ConfigModule.IsGlobal)
+            {
+                param["region"] = "CN";
+            }
+
+            if (!string.IsNullOrEmpty(ConfigModule.TargetCountryOrRegion))
+            {
+                param["countryCode"] = ConfigModule.TargetCountryOrRegion;
+            }
+
+            return param;
+        }
+
+        public void SetTargetCountryOrRegion(string countryOrRegion)
+        {
+            ConfigModule.TargetCountryOrRegion = countryOrRegion;
+        }
+
+        private async Task Init(XDGInitParam param)
+        {
+            if (isIniting)
+            {
+                XDGLogger.Warn("正在初始化...");
+                return;
+            }
+
+            if (isInited)
+            {
+                XDGLogger.Warn("已经初始化");
+                return;
+            }
+
+            isIniting = true;
+
+            try
+            {
+                SetLanguage(param.Lang);
+                ConfigModule.LoadConfig(param);
+
+                AliyunTrack.Init();
+
+                await AgreementModule.ConfirmAgreement();
+
+                _ = ConfigModule.FetchConfig();
+
+                _ = XDGAreaCode.FetchAreaCodes();
+                
+                IPInfoModule.RequestIpInfoAndSave();
+
+                InitTap(param);
+
+                //TODO 注册防沉迷回调
+                RegisterTapComplianceCallback();
+                
+                InitWebViewUa();
+                isInited = true;
+            }
+            catch (Exception e)
+            {
+                isInited = false;
+                throw e;
+            }
+            finally
+            {
+                isIniting = false;
+            }
+        }
+
+        private static void InitTap(XDGInitParam initParam)
+        {
+            var tapConfig = ConfigModule.TapConfig;
+
+            XDGEventBus.Publish(XDGEvents.TapSDKInit, tapConfig.ClientId,
+                tapConfig.ClientToken,
+                initParam.Lang.FormatToXDLangString(),
+                ConfigModule.IsGlobal,
+                true, // enableLog - TODO: 根据配置判断
+                tapConfig.DBConfig.Enable,
+                GetChannel(tapConfig.DBConfig.Channel));
+
+            XDGEventBus.Publish(XDGEvents.TdsSDKInit, tapConfig.ClientId,
+                tapConfig.ClientToken,
+                tapConfig.ServerUrl);
+        }
+
+        private static string GetChannel(string defaultChannel)
+        {
+#if UNITY_STANDALONE_WIN
+            var fileName = ConfigModule.ClientId;
+            var basePath = ConfigModule.IsGlobal
+                ? $"SOFTWARE\\XD Global Games\\{fileName}"
+                : $"SOFTWARE\\XD Games\\{fileName}";
+            return WindowsRegistryAccess.ReadRegistryValue(basePath, "channel", defaultChannel);
+#endif
+            return defaultChannel;
+        }
+
+        private static void RegisterTapComplianceCallback()
+        {
+            try
+            {
+                XDGEventBus.Publish(XDGEvents.TapSDKRegisterComplianceCallback, ConfigModule.IsGlobal);
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error($"注册防沉迷回调失败: {e.Message}");
+            }
+        }
+
+        private static void InitWebViewUa()
+        {
+            var region = ConfigModule.IsGlobal ? "global" : "cn";
+            //TODO 设置 UserAgent 提前
+            // Web.SetUserAgent(
+                // $"{WebBridgeConstants.UserAgent} Unity/{Application.unityVersion} XDSDK/{XDGConstants.SDK_VERSION} ({XDGConstants.SDK_VERSION_CODE}; {region})");
+            //
+        }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/Config/AppConfig.cs

@@ -0,0 +1,68 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class BindEntryConfig
+    {
+        [JsonProperty("canBind")] public int CanBind { get; set; }
+
+        [JsonProperty("entryName")] public string EntryName { get; set; }
+
+        [JsonProperty("canUnbind")] public int CanUnbind { get; set; }
+    }
+    
+    public class AppConfig
+    {
+        [JsonProperty("client_id")] public string ClientId { get; internal set; }
+
+        [JsonProperty("region_type")] public string RegionType { get; internal set; }
+
+        [JsonProperty("game_name")] public string GameName { get; internal set; }
+
+        [JsonProperty("app_id")] public string AppId { get; internal set; }
+
+        [JsonProperty("tapsdk")] public TapSDKConfig TapConfig { get; internal set; }
+
+        [JsonProperty("web_pay_url")] public string WebPayUrl { get; internal set; }
+
+        [JsonProperty("webpay_url_for_pc")] public string WebPayUrlForPC { get; internal set; }
+
+        [JsonProperty("report_url")] public string ReportUrl { get; internal set; }
+
+        [JsonProperty("logout_url")] public string CancelUrl { get; internal set; }
+
+        [JsonProperty("google")] public GoogleConfig Google { get; internal set; }
+
+        [JsonProperty("apple")] public AppleConfig Apple { get; internal set; }
+
+        [JsonProperty("facebook")] public FacebookConfig Facebook { get; internal set; }
+
+        [JsonIgnore] public string Region { get; internal set; }
+        
+        [JsonIgnore] public List<BindEntryConfig> BindEntryConfigs { get; internal set; }
+        
+        [JsonIgnore] public List<string> WebWhiteList { get; set; }
+        
+        [JsonIgnore] public string PackageType;
+        
+        [JsonIgnore] public bool DisableAutoLogin2Tap { get; set; }
+        
+
+        /// <summary>
+        /// 判断是否为海外
+        /// </summary>
+        internal bool IsGlobal => RegionType == "Global";
+
+        public bool UsingTapPC()
+        {
+#if UNITY_STANDALONE_WIN
+            // win 环境 + packageType 为 tapPC + clientPublicKey 不为空
+            return !IsGlobal && string.Equals(PackageType, XDGPackageType.PackageTypePCTapTap) && TapConfig != null && !string.IsNullOrEmpty(TapConfig.ClientPublicKey);
+#endif
+            return false;
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Config/AppConfig.cs.meta

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

package/Runtime/Internal/Standalone/Config/AppleConfig.cs

@@ -0,0 +1,11 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class AppleConfig
+    {
+        [JsonProperty("service_id")] public string ClientId { get; internal set; }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Config/AppleConfig.cs.meta

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

package/Runtime/Internal/Standalone/Config/Config.cs

@@ -0,0 +1,27 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class Config
+    {
+        [JsonProperty("region")] public string Region { get; private set; }
+
+        [JsonProperty("bindEntriesConfig")] public List<BindEntryConfig> BindEntryConfigs { get; set; }
+        [JsonProperty("appId")] public string AppId { get; private set; }
+
+        [JsonProperty("webPayUrl")] public string WebPayUrl { get; private set; }
+
+        [JsonProperty("webPayUrlForPC")] public string WebPayUrlForPC { get; private set; }
+
+        [JsonProperty("reportUrl")] public string ReportUrl { get; private set; }
+
+        [JsonProperty("logoutUrl")] public string CancelUrl { get; private set; }
+
+        [JsonProperty("webWhiteList")] public List<string> WebWhiteList { get; private set; }
+
+        [JsonProperty("disableAutoLogin2Tap")] public bool DisableAutoLogin2Tap { get; private set; }
+    }
+}
+#endif

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

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

package/Runtime/Internal/Standalone/Config/ConfigModule.cs

@@ -0,0 +1,224 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using UnityEditor;
+using UnityEngine;
+
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class ConfigModule
+    {
+        private const string FetchConfigUrl = "api/init/v1/config";
+
+        private static string ConfigFile = "XDConfig";
+
+        public static readonly List<string> WEB_WHITE_LIST = new List<string>
+        {
+            //TODO 正式环境删除 LocalHost
+            "xd.com", "xd.cn", "localhost"
+        };
+
+        private static readonly Persistence Persistence = new Persistence(Path.Combine(
+            Application.persistentDataPath,
+            XDGConstants.XD_PERSISTENCE_NAME,
+            "config"));
+
+        private static AppConfig _appConfig;
+
+        public static string TargetCountryOrRegion;
+
+        private static string LoadConfigText()
+        {
+#if UNITY_EDITOR
+            var xdConfigFilePath = GetXDConfigPath(ConfigFile);
+#else
+            var xdConfigFilePath = Path.Combine(Application.streamingAssetsPath, $"{ConfigFile}.json");
+#endif
+            return File.ReadAllText(xdConfigFilePath);
+        }
+
+        private static string GetXDConfigPath(string fileName)
+        {
+            string xdconfigPath = null;
+
+            var parentFolder = Directory.GetParent(Application.dataPath)?.FullName;
+            xdconfigPath = Path.Combine(parentFolder, $"Assets/{fileName}.json");
+
+            if (File.Exists(xdconfigPath))
+            {
+                return xdconfigPath;
+            }
+
+            Debug.LogWarningFormat($"[XDSDK.Common] Can't find {fileName}.json on Assets folder");
+            xdconfigPath = Path.Combine(parentFolder, $"Assets/Plugins/{fileName}.json");
+
+            if (File.Exists(xdconfigPath))
+            {
+                return xdconfigPath;
+            }
+
+            Debug.LogWarningFormat(
+                $"[XDSDK.Common] Can't find {fileName}.json on Assets folder or Assets/Plugins folder");
+#if UNITY_EDITOR
+            bool find = false;
+            var xdconfigGuids = AssetDatabase.FindAssets(fileName);
+            foreach (var guid in xdconfigGuids)
+            {
+                var xdPath = AssetDatabase.GUIDToAssetPath(guid);
+                var fileInfo = new FileInfo(xdPath);
+                if (fileInfo.Name != $"{fileName}.json") continue;
+                xdconfigPath = Path.Combine(parentFolder, xdPath);
+                find = true;
+                break;
+            }
+
+            if (find)
+            {
+                Debug.LogFormat($"[XDSDK.Common] Can find {fileName}.json at: {xdconfigPath}");
+                return xdconfigPath;
+            }
+#endif
+            Debug.LogFormat($"[XDSDK.Common] CAN NOT find {fileName}.json!!");
+            return "";
+        }
+
+        public static void LoadConfig(XDGInitParam param)
+        {
+            var txtAsset = LoadConfigText();
+            _appConfig = JsonConvert.DeserializeObject<AppConfig>(txtAsset);
+            _appConfig.PackageType = param?.PackageType;
+            if (string.IsNullOrEmpty(_appConfig.WebPayUrl))
+            {
+                _appConfig.WebPayUrl = _appConfig.IsGlobal ? "https://sdkpay.xd.com" : "https://sdkpay.xd.cn";
+            }
+
+            if (string.IsNullOrEmpty(_appConfig.WebPayUrlForPC))
+            {
+                _appConfig.WebPayUrlForPC = _appConfig.IsGlobal ? "https://sdkpay.xd.com" : "https://sdkpay.xd.cn";
+            }
+
+            if (string.IsNullOrEmpty(_appConfig.CancelUrl))
+            {
+                _appConfig.CancelUrl = _appConfig.IsGlobal ? "https://logout-xdsdk.xd.com" : "https://logout-xdsdk.xd.cn";
+            }
+
+            if (_appConfig.TapConfig != null && _appConfig.TapConfig.DBConfig != null)
+            {
+                if (string.IsNullOrEmpty(_appConfig.TapConfig.DBConfig.Version))
+                {
+                    _appConfig.TapConfig.DBConfig.Version = Application.version;
+                }
+
+                // 优先用代码中的 channel
+                if (param != null && !string.IsNullOrEmpty(param.Channel))
+                {
+                    _appConfig.TapConfig.DBConfig.Channel = param.Channel;
+                }
+            }
+
+            _appConfig.WebWhiteList = WEB_WHITE_LIST;
+        }
+
+        public static async Task FetchConfig()
+        {
+            Config config = null;
+            try
+            {
+                var response = await XDHttpClient.Client.GetAsync<ConfigResponse>(FetchConfigUrl);
+                config = response.ConfigData.Config;
+                await Persistence.Save(config);
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn($"拉取配置失败: {e}");
+                config = await Persistence.Load<Config>();
+            }
+
+            if (config != null)
+            {
+                _appConfig.Region = config.Region;
+                _appConfig.BindEntryConfigs = config.BindEntryConfigs;
+                if (!string.IsNullOrEmpty(config.AppId))
+                {
+                    _appConfig.AppId = config.AppId;
+                }
+
+                if (!string.IsNullOrEmpty(config.WebPayUrl))
+                {
+                    _appConfig.WebPayUrl = config.WebPayUrl;
+                }
+
+                if (!string.IsNullOrEmpty(config.WebPayUrlForPC))
+                {
+                    _appConfig.WebPayUrlForPC = config.WebPayUrlForPC;
+                }
+
+                if (!string.IsNullOrEmpty(config.ReportUrl))
+                {
+                    _appConfig.ReportUrl = config.ReportUrl;
+                }
+
+                if (!string.IsNullOrEmpty(config.CancelUrl))
+                {
+                    _appConfig.CancelUrl = config.CancelUrl;
+                }
+
+                if (config.WebWhiteList != null && config.WebWhiteList.Count > 0)
+                {
+                    _appConfig.WebWhiteList = config.WebWhiteList;
+                }
+
+                _appConfig.DisableAutoLogin2Tap = config.DisableAutoLogin2Tap;
+            }
+
+            _ = UploadConfigModule.TryUploadConfig();
+        }
+
+        public static string ClientId => _appConfig.ClientId;
+
+        public static string GameName => _appConfig.GameName;
+
+        public static string RegionType => _appConfig.RegionType;
+
+        public static TapSDKConfig TapConfig => _appConfig.TapConfig;
+
+        public static string AppId => _appConfig.AppId;
+
+        public static string WebPayUrl => _appConfig.WebPayUrl;
+
+        public static string WebPayUrlForPC => _appConfig.WebPayUrlForPC;
+
+        public static string Region =>
+            !string.IsNullOrEmpty(TargetCountryOrRegion) ? TargetCountryOrRegion : _appConfig.Region;
+
+        public static string Channel => _appConfig.TapConfig?.DBConfig?.Channel;
+
+        public static List<BindEntryConfig> BindEntryConfigs => _appConfig.BindEntryConfigs;
+
+        public static List<string> BindEntries => BindEntryConfigs?.Select(item => item.EntryName)?.ToList();
+
+        public static string ReportUrl => _appConfig.ReportUrl;
+
+        public static GoogleConfig Google => _appConfig.Google;
+
+        public static AppleConfig Apple => _appConfig.Apple;
+
+        public static FacebookConfig Facebook => _appConfig.Facebook;
+
+        public static List<string> WebWhiteList => _appConfig?.WebWhiteList;
+
+        public static bool IsGlobal => _appConfig.IsGlobal;
+
+        public static bool UsingTapPC => _appConfig.UsingTapPC();
+
+        public static bool DisableAutoLogin2Tap => _appConfig.DisableAutoLogin2Tap;
+
+        public static string CancelUrl => _appConfig.CancelUrl;
+    }
+}
+#endif