com.xd.sdk.common 6.29.1 → 7.0.0

package/Runtime/Internal/Standalone/Web/XDWebBridgeView.cs

@@ -0,0 +1,301 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using UnityEngine;
+using UnityEngine.UI;
+using Vuplex.WebView;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class XDWebBridgeView : UIElement, IWebTransmit
+    {
+        private Image background;
+
+        private CanvasWebViewPrefab canvasWebViewPrefab;
+        private Button backButton;
+        private Button closeButton;
+
+        private GameObject errorPanelObject;
+        private Button retryButton;
+        private Coroutine closeButtonCoroutine;
+        private float timer;
+
+        private GameObject navigationView;
+        private Text navigationTitle;
+
+        private WebBridgeController webBridgeController;
+
+        public async void Reload()
+        {
+            ParseUriToInitWebView(extra["url"] as string);
+            errorPanelObject.SetActive(false);
+            var url = extra["url"] as string;
+            canvasWebViewPrefab.WebView.LoadUrl(url);
+            await canvasWebViewPrefab.WebView.WaitForNextPageLoadToFinish();
+            UIManager.DismissLoading();
+        }
+
+        private void Awake()
+        {
+            background = transform.Find("WebView").GetComponent<Image>();
+            // canvasWebViewPrefab = transform.Find("WebView/CanvasWebViewPrefab").GetComponent<CanvasWebViewPrefab>();
+            backButton = transform.Find("WebView/BackButton").GetComponent<Button>();
+            backButton.onClick.AddListener(OnBackButtonClicked);
+            closeButton = transform.Find("WebView/CloseButton").GetComponent<Button>();
+            closeButton.onClick.AddListener(OnCloseButtonClicked);
+
+            errorPanelObject = transform.Find("WebView/LoadFailedView").gameObject;
+            retryButton = transform.Find("WebView/LoadFailedView/RetryButton").GetComponent<Button>();
+
+            navigationView = transform.Find("WebView/NavigationView").gameObject;
+            navigationTitle = transform.Find("WebView/NavigationTitle").GetComponent<Text>();
+
+            var webViewGameObject = Instantiate(Resources.Load(nameof(CanvasWebViewPrefab)), transform.Find("WebView/WebViewContainer"), false) as GameObject;
+            canvasWebViewPrefab = webViewGameObject?.GetComponent<CanvasWebViewPrefab>();
+
+            errorPanelObject.SetActive(false);
+            retryButton.onClick.AddListener(Reload);
+
+            Input.imeCompositionMode = IMECompositionMode.On;
+        }
+
+
+        private async void Start()
+        {
+            canvasWebViewPrefab.Visible = false;
+            await canvasWebViewPrefab.WaitUntilInitialized();
+            canvasWebViewPrefab.Visible = true;
+            canvasWebViewPrefab.WebView.SetDefaultBackgroundEnabled(false);
+            canvasWebViewPrefab.WebView.PageLoadScripts.Add(WebBridgeConstants.InnerHtml);
+            canvasWebViewPrefab.WebView.UrlChanged += OnUrlChanged;
+            canvasWebViewPrefab.WebView.PageLoadFailed += OnPageLoadFailed;
+            webBridgeController = new WebBridgeController(canvasWebViewPrefab.WebView, this);
+            if (extra["interceptor"] != null)
+            {
+                List<IWebFunction> interceptorFunctions = extra["interceptor"] as List<IWebFunction>;
+                if (interceptorFunctions != null)
+                    foreach (var interceptorFunction in interceptorFunctions)
+                    {
+                        webBridgeController.RegisterHandler(interceptorFunction);
+                    }
+            }
+
+            Reload();
+        }
+
+        private void OnDestroy()
+        {
+            canvasWebViewPrefab.Destroy();
+            webBridgeController.Release();
+        }
+
+        private async void OnBackButtonClicked()
+        {
+            var canBack = await canvasWebViewPrefab.WebView.CanGoBack();
+            if (canBack)
+            {
+                canvasWebViewPrefab.WebView.GoBack();
+            }
+            else
+            {
+                OnCloseButtonClicked();
+            }
+        }
+
+        private void OnCloseButtonClicked()
+        {
+            UIManager.Dismiss();
+            UIManager.DismissLoading();
+            OnCallback((int)WebActionEnum.CLOSE, null);
+        }
+
+        private void OnUrlChanged(object sender, UrlChangedEventArgs eventArgs)
+        {
+            if (Application.internetReachability == NetworkReachability.NotReachable)
+            {
+                UIManager.DismissLoading();
+                errorPanelObject.SetActive(true);
+            }
+            else
+            {
+                errorPanelObject.SetActive(false);
+            }
+        }
+
+        private void OnPageLoadFailed(object sender, EventArgs eventArgs)
+        {
+            UIManager.DismissLoading();
+            errorPanelObject.SetActive(true);
+        }
+
+        private IEnumerator StartTimer()
+        {
+            while (timer > 0)
+            {
+                timer -= Time.deltaTime; // 减少定时器
+                yield return null; // 等待下一帧
+            }
+
+            closeButton.gameObject.SetActive(true);
+        }
+
+        private void ParseUriToInitWebView(string url)
+        {
+            var queryParams = ParseQueryString(url);
+            var bgColor = GetValueOrDefault(queryParams, "xdBgColor", WebBridgeConstants.DefaultBgColor);
+            var close = GetValueOrDefault(queryParams, "xdClose", "1") == "1";
+            var loading = GetValueOrDefault(queryParams, "xdLoading", "1") == "1";
+            var nav = GetValueOrDefault(queryParams, "xdNav", "1") == "1";
+            var title = Uri.UnescapeDataString(GetValueOrDefault(queryParams, "xdTitle", ""));
+
+            HandlerCloseButtonVisible(new WebCloseButtonBean
+            {
+                Visible = close,
+                Duration = 3f
+            });
+
+            HandlerNavigation(new WebNavigationBean
+            {
+                Title = title,
+                Visible = nav
+            });
+
+            HandlerBackgroundColor(bgColor);
+
+            if (loading)
+            {
+                UIManager.ShowLoading();
+            }
+        }
+
+        public void Transparent(string functionName, string data)
+        {
+            switch (functionName)
+            {
+                case NavigationWebFunction.Tag:
+                    HandlerNavigation(JsonConvert.DeserializeObject<WebNavigationBean>(data));
+                    break;
+                case CloseVisibleWebFunction.Tag:
+                    HandlerCloseButtonVisible(JsonConvert.DeserializeObject<WebCloseButtonBean>(data));
+                    break;
+                case BackgroundColorWebFunction.Tag:
+                    var dict = JsonConvert.DeserializeObject<Dictionary<string, string>>(data);
+                    dict.TryGetValue("backgroundColor", out var color);
+                    HandlerBackgroundColor(color);
+                    break;
+            }
+        }
+
+        private void HandlerCloseButtonVisible(WebCloseButtonBean bean)
+        {
+            if (bean == null)
+            {
+                bean = new WebCloseButtonBean
+                {
+                    Visible = true,
+                    Duration = 3f
+                };
+            }
+
+            closeButton.gameObject.SetActive(bean.Visible);
+            if (closeButtonCoroutine != null)
+            {
+                StopCoroutine(closeButtonCoroutine);
+            }
+
+            timer = bean.Duration;
+            closeButtonCoroutine = StartCoroutine(StartTimer());
+        }
+
+        private void HandlerBackgroundColor(string bgColor)
+        {
+            if (!background.IsActive()) return;
+            if (string.IsNullOrEmpty(bgColor))
+            {
+                bgColor = WebBridgeConstants.DefaultBgColor;
+            }
+
+            if (!bgColor.StartsWith("#"))
+            {
+                bgColor = "#" + bgColor;
+            }
+
+            background.color = ParseColor(bgColor);
+        }
+
+        private void HandlerNavigation(WebNavigationBean bean)
+        {
+            if (bean == null)
+            {
+                navigationView.SetActive(false);
+                navigationTitle.gameObject.SetActive(false);
+                backButton.gameObject.SetActive(false);
+                return;
+            }
+
+            if (!string.IsNullOrEmpty(bean.Title) && bean.Visible)
+            {
+                navigationTitle.gameObject.SetActive(true);
+                navigationTitle.text = bean.Title;
+            }
+            else
+            {
+                navigationTitle.gameObject.SetActive(false);
+            }
+
+            navigationView.SetActive(bean.Visible);
+            backButton.gameObject.SetActive(bean.Visible);
+            navigationTitle.gameObject.SetActive(bean.Visible);
+            var webViewTransform = canvasWebViewPrefab.gameObject.GetComponent<RectTransform>();
+            var navigationForm = navigationView.GetComponent<RectTransform>();
+            webViewTransform.offsetMax = bean.Visible
+                ? new Vector2(webViewTransform.offsetMax.x, -navigationForm.sizeDelta.y)
+                : new Vector2(webViewTransform.offsetMax.x, 0);
+        }
+
+        public void TransObserver(WebActionEnum type, Dictionary<string, object> dict)
+        {
+            OnCallback((int)type, dict);
+        }
+
+        private static Color ParseColor(string color)
+        {
+            if (string.IsNullOrEmpty(color))
+            {
+                color = WebBridgeConstants.DefaultBgColor;
+            }
+
+            ColorUtility.TryParseHtmlString(color, out var c);
+            return c;
+        }
+
+        private static Dictionary<string, string> ParseQueryString(string url)
+        {
+            var uri = new Uri(url);
+            if (string.IsNullOrWhiteSpace(uri.Query))
+            {
+                return new Dictionary<string, string>();
+            }
+
+            var dic = uri.Query.Substring(1)
+                .Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(param => param.Split(new[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries))
+                .GroupBy(part => part[0], part => part.Length > 1 ? part[1] : string.Empty)
+                .ToDictionary(group => group.Key, group => string.Join(",", group));
+            return dic;
+        }
+
+        private static TValue GetValueOrDefault<TKey, TValue>(
+            IReadOnlyDictionary<TKey, TValue> dictionary,
+            TKey key,
+            TValue defaultValue)
+        {
+            if (dictionary == null) return defaultValue;
+            return dictionary.TryGetValue(key, out var obj) ? obj : defaultValue;
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/XDWebBridgeView.cs.meta

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

package/Runtime/Internal/Standalone/Web.meta

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

package/Runtime/Internal/Standalone.meta

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

package/Runtime/Internal/XDGAgreement.cs

@@ -1,8 +1,21 @@
-namespace XD.SDK.Common
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Common.Internal
 {
-    public interface XDGAgreement
+    public class XDGAgreement
     {
-        string type { get; }
-        string url { get; }
+        [JsonProperty("type")]
+        public string Type { get; }
+        [JsonProperty("url")]
+        public string Url { get; }
+
+        public XDGAgreement(Dictionary<string, object> dic)
+        {
+            if (dic == null) return;
+            Type = XDDictionary.GetValue<string>(dic, "type");
+            Url = XDDictionary.GetValue<string>(dic, "url");
+        }
     }
 }

package/Runtime/Internal/XDGAgreement.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 0f39542d9c9e4e739479062188c619c7
+guid: 273a65ca80ff4b2d8e89822c08fd6d83
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/Internal/XDGCommonInternal.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal
+{
+    public class XDGCommonInternal
+    {
+        private static IXDGCommonExtended platformWrapper;
+
+        static XDGCommonInternal()
+        {
+#if UNITY_IOS || UNITY_ANDROID
+            platformWrapper = XD.SDK.Common.Internal.Mobile.CommonFeaturesImpl.Instance;
+#elif UNITY_STANDALONE
+            platformWrapper = XD.SDK.Common.Internal.Standalone.CommonFeaturesImpl.Instance;
+#endif
+            if (platformWrapper == null)
+            {
+                XDGLogger.Error("unsupported platform: " + Application.platform);
+            }
+        }
+
+        #region 公开接口
+
+        public static void InitSDK(XDGInitParam param, Action<bool, string> callback)
+        {
+            platformWrapper.InitSDK(param, callback);
+        }
+
+        public static bool IsInitialized()
+        {
+            return platformWrapper.IsInitialized();
+        }
+
+        public static void SetLanguage(LangType langType)
+        {
+            platformWrapper.SetLanguage(langType);
+        }
+
+        public static void StoreReview()
+        {
+            platformWrapper.StoreReview();
+        }
+
+        // public static string GetVersionName()
+        // {
+        //     return platformWrapper.GetVersionName();
+        // }
+
+        public static void TrackUser(string userId)
+        {
+            platformWrapper.TrackUser(userId);
+        }
+
+        public static void TrackRole(XDGRoleInfo role)
+        {
+            platformWrapper.TrackRole(role);
+        }
+
+        public static void TrackEvent(string eventName, Dictionary<string, object> properties = null)
+        {
+            platformWrapper.TrackEvent(eventName, properties);
+        }
+
+        public static void PreloadWebPage(string url)
+        {
+            platformWrapper.PreloadWebPage(url);
+        }
+
+        public static void OpenWebPage(string url, Action<WebActionEnum, Dictionary<string, object>> callback)
+        {
+            platformWrapper.OpenWebPage(url, callback);
+        }
+
+        #endregion
+
+        #region 内部接口
+
+        public static bool IsCn()
+        {
+            return platformWrapper.IsCn();
+        }
+        
+        public static Dictionary<string, string> GetCommonQueryParams(string url, long timestamp)
+        {
+            return platformWrapper.GetCommonQueryParams(url, timestamp);
+        }
+
+        public static void DisableAgreementUI()
+        {
+            platformWrapper.DisableAgreementUI();
+        }
+
+        public static void SetTargetCountryOrRegion(string region)
+        {
+            platformWrapper.SetTargetCountryOrRegion(region);
+        }
+
+        #endregion
+    }
+}

package/Runtime/Internal/XDGCommonInternal.cs.meta

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

package/Runtime/Internal.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: df3e55f612cc4d968f815e1710d69ff8
+guid: 0260b0b9b96d47b3a2cb8e6cfc8c9353
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/Public/XDGCommon.Deprecated.cs

@@ -0,0 +1,163 @@
+#if XDSDK_DEPRECATED
+using System;
+using System.Collections.Generic;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Common
+{
+    partial class XDGCommon
+    {
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void InitSDK(Action<bool, string> callback)
+        {
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void IsInitialized(Action<bool> callback)
+        {
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void Share(ShareFlavors shareFlavors, string uri, XDGShareCallback callback)
+        {
+
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void Share(ShareFlavors shareFlavors, string uri, string message, XDGShareCallback callback)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void Report(string serverId, string roleId, string roleName)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void TrackRole(string serverId, string roleId, string roleName, int level)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void TrackUser(string userId = null)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void EventCompletedTutorial()
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void EventCreateRole()
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void GetVersionName(Action<string> callback)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void TrackAchievement()
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void SetCurrentUserPushServiceEnable(bool enable)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void IsCurrentUserPushServiceEnable(Action<bool> callback)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void ShowLoading()
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void HideLoading()
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void GetRegionInfo(Action<XDGRegionInfoWrapper> callback)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void DisableAgreementUI()
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void ReplaceChannelAndVersion(string channel, string gameVersion)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void GetAgreementList(Action<List<XDGAgreement>> callback)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void ShowDetailAgreement(string agreementUrl)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void SetExitHandler(Action onExitHandler)
+        {
+            
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void ValidateWithCaptcha(string scene, Action<string, XDGError> callback)
+        {
+            
+        }
+    }
+
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public interface XDGShareCallback
+    {
+        void ShareSuccess();
+        void ShareCancel();
+        void ShareFailed(string error);
+    }
+    
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public enum ShareFlavors
+    {
+        FACEBOOK = 0,
+        LINE = 1,
+        TWITTER = 2,
+    }
+
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public interface XDGRegionInfoWrapper
+    {
+        XDGRegionInfo info { get; }
+    }
+}
+#endif

package/Runtime/Public/XDGCommon.Deprecated.cs.meta

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