com.xd.sdk.common 0.0.1 → 0.0.10-alpha

package/Runtime/Internal/Standalone/Web/Function/GetStorageWebFunction.cs

@@ -0,0 +1,42 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class GetStorageWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "get";
+        }
+
+        public void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            var dic = JsonConvert.DeserializeObject<Dictionary<string, string>>(data);
+            if (!dic.TryGetValue("key", out var key)) return;
+            var value = DataStorage.LoadString(key);
+            dic.TryGetValue("defaultValue", out var defaultValue);
+            if (string.IsNullOrEmpty(value) && string.IsNullOrEmpty(defaultValue))
+            {
+                callbackFunction(new WebBridgeResponse.Failed
+                {
+                    Msg = "key not exist"
+                });
+                return;
+            }
+
+            callbackFunction(new WebBridgeResponse.Success
+            {
+                Data = new Dictionary<string, object>
+                {
+                    { "value", string.IsNullOrEmpty(value) ? defaultValue : value }
+                }
+            });
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/GetStorageWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/HttpRequestWebFunction.cs

@@ -0,0 +1,93 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using Newtonsoft.Json;
+using XD.SDK.Common.Internal;
+
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class HttpRequestWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "httpRequest";
+        }
+
+        public async void Handler(IBridgeWebView webView, string data, Action<object> callback)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            var webParams = JsonConvert.DeserializeObject<WebHttpRequest>(data);
+            HttpMethod method;
+            switch (webParams.RequestType)
+            {
+                case "get": method = HttpMethod.Get; break;
+                case "post": method = HttpMethod.Post; break;
+                default:
+                    callback(new WebBridgeResponse.Failed
+                    {
+                        Msg = "request type not support"
+                    });
+                    return;
+            }
+
+            webParams.Extra.TryGetValue("showLoading", out object showLoading);
+            if (showLoading is bool)
+            {
+                if ((bool)showLoading)
+                {
+                    UIManager.ShowLoading();
+                }
+            }
+
+            try
+            {
+                // var response = await XDHttpClient.Client.<Dictionary<string, object>>(
+                //     webParams.Url,
+                //     method,
+                //     webParams.Header,
+                //     method == HttpMethod.Post ? webParams.Params : null,
+                //     method == HttpMethod.Get ? webParams.Params : null,
+                //     CancellationToken.None
+                // );
+                // XDGLogger.Debug($"message from web {JsonConvert.SerializeObject(response)}");
+                // callback(
+                //     new WebBridgeResponse.Success
+                //     {
+                //         Data = response
+                //     });
+            }
+            catch (XDHttpException e)
+            {
+                callback(new WebBridgeResponse.Failed
+                {
+                    Msg = e.Message,
+                    Error = new Dictionary<string, object>
+                    {
+                        { "code", e.Code },
+                        { "msg", e.ErrorMsg },
+                        { "errorDataMap", e.ExtraData }
+                    }
+                });
+            }
+            finally
+            {
+                UIManager.DismissLoading();
+            }
+        }
+
+        private HttpMethod ParseMethod(string method)
+        {
+            switch (method)
+            {
+                case "get": return HttpMethod.Get;
+                case "post": return HttpMethod.Post;
+                default: throw new Exception("method not support");
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/HttpRequestWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/LoadingWebFunction.cs

@@ -0,0 +1,46 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using Newtonsoft.Json;
+using Task = System.Threading.Tasks.Task;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class LoadingWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "loading";
+        }
+
+        public async void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            var bean = JsonConvert.DeserializeObject<LoadingBean>(data);
+            if (bean == null)
+            {
+                UIManager.DismissLoading();
+                return;
+            }
+
+            if (bean.Show)
+            {
+                UIManager.ShowLoading();
+                if (bean.Duration <= 0)
+                {
+                    bean.Duration = 5;
+                }
+                await Task.Delay(bean.Duration * 1000);
+            }
+
+            UIManager.DismissLoading();
+        }
+    }
+
+    public class LoadingBean
+    {
+        [JsonProperty("show")] public bool Show { get; set; }
+        [JsonProperty("duration")] public int Duration { get; set; }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/LoadingWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/LogWebFunction.cs

@@ -0,0 +1,38 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class LogWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "log";
+        }
+
+        public void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            try
+            {
+                var message = JsonConvert.DeserializeObject<Dictionary<string, object>>(data);
+                var logLevel = message["logLevel"] as string;
+                var text = message["text"] as string;
+                switch (logLevel)
+                {
+                    case "DEBUG": XDGLogger.Debug(text); break;
+                    case "WARN": XDGLogger.Warn(text); break;
+                    case "ERROR": XDGLogger.Error(text); break;
+                }
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Debug(JsonConvert.SerializeObject(e));
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/LogWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/NavigationWebFunction.cs

@@ -0,0 +1,23 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class NavigationWebFunction : IWebFunction
+    {
+        public const string Tag = "navigation";
+
+        public string GetName()
+        {
+            return Tag;
+        }
+
+        public void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            webView.ProviderWebTrans().Transparent(GetName(), data);
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/NavigationWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/OpenPageWebFunction.cs

@@ -0,0 +1,56 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class OpenPageWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "openPage";
+        }
+
+        public void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            var bean = JsonConvert.DeserializeObject<OpenPageBean>(data);
+            if (string.IsNullOrEmpty(bean.URL)) return;
+            switch (bean.Type)
+            {
+                case "replace":
+                {
+                    if (bean.URL.Contains("http"))
+                    {
+                        webView.ProviderWebView().LoadUrl(bean.URL);
+                    }
+                    else
+                    {
+                        webView.ProviderWebView().LoadHtml(bean.URL);
+                    }
+
+                    return;
+                }
+                case "newPage":
+                    UIManager.ShowUI<XDWebBridgeView>("XDWebBridgeView", new Dictionary<string, object>
+                    {
+                        { "url", bean.URL }
+                    }, null);
+                    return;
+                default:
+                    Application.OpenURL(bean.URL);
+                    break;
+            }
+        }
+    }
+
+    class OpenPageBean
+    {
+        [JsonProperty("url")] public string URL { get; set; }
+        [JsonProperty("type")] public string Type { get; set; }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/OpenPageWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/PutStorageWebFunction.cs

@@ -0,0 +1,38 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class PutStorageWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "put";
+        }
+
+        public void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            try
+            {
+                var dic = JsonConvert.DeserializeObject<Dictionary<string, string>>(data);
+                if (!dic.TryGetValue("key", out var key)) return;
+                if (dic.TryGetValue("value", out var value))
+                {
+                    DataStorage.SaveString(key, value);
+                }
+            }
+            catch (Exception e)
+            {
+                callbackFunction(new WebBridgeResponse.Failed
+                {
+                    Msg = e.Message
+                });
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/PutStorageWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/ToastWebFunction.cs

@@ -0,0 +1,25 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class ToastWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "toast";
+        }
+
+        public void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            var message = JsonConvert.DeserializeObject<Dictionary<string, object>>(data)["message"] as string;
+            UIManager.ShowToast(message);
+        }
+    }
+    
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/ToastWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/TrackEventWebFunction.cs

@@ -0,0 +1,23 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class TrackEventWebFunction : IWebFunction
+    {
+        public string GetName()
+        {
+            return "trackEvent";
+        }
+
+        public void Handler(IBridgeWebView webView, string data, Action<object> callbackFunction)
+        {
+            XDGLogger.Debug($"message from javascript by:{GetName()} with data:{data}");
+            var trackEventBean = JsonConvert.DeserializeObject<WebTrackEventBean>(data);
+            XDGCommon.TrackEvent(trackEventBean.TrackEvent, trackEventBean.EventsMap);
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/TrackEventWebFunction.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function/WebFunctionHolder.cs

@@ -0,0 +1,75 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System.Collections.Generic;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class WebFunctionHolder
+    {
+        private static WebFunctionHolder _instance;
+
+        private readonly List<IWebFunction> functions = new List<IWebFunction>();
+
+        private WebFunctionHolder()
+        {
+        }
+
+        public List<IWebFunction> GetWebFunctionHolder()
+        {
+            return functions;
+        }
+
+        public static WebFunctionHolder Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new WebFunctionHolder();
+                }
+
+                if (_instance.functions.Count <= 0)
+                {
+                    _instance.functions.AddRange(
+                        new List<IWebFunction>
+                        {
+                            new HttpRequestWebFunction(),
+                            new LogWebFunction(),
+                            new ToastWebFunction(),
+                            new LoadingWebFunction(),
+                            new CloseWebFunction(),
+                            new GetSafeAreaWebFunction(),
+                            new BackgroundColorWebFunction(),
+                            new NavigationWebFunction(),
+                            new ClipboardWebFunction(),
+                            new DeviceInfoWebFunction(),
+                            new GetStorageWebFunction(),
+                            new PutStorageWebFunction(),
+                            new OpenPageWebFunction(),
+                            new TrackEventWebFunction(),
+                            new CloseVisibleWebFunction(),
+                            new GameMessageWebFunction(),
+
+                            //通过反射构造 Account 模块中的 WebFunction
+                            CreateWebFunction<IWebFunction>("XD.SDK.Account.Internal.Standalone.AccessTokenWebFunction")
+                        });
+                }
+
+                return _instance;
+            }
+        }
+
+        private static T CreateWebFunction<T>(string typeName) where T : class
+        {
+            var type = ReflectionUtils.FindType(typeName);
+            if (type != null)
+            {
+                var instance = ReflectionUtils.CreateInstance(type);
+                return instance as T;
+            }
+
+            return null;
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Web/Function/WebFunctionHolder.cs.meta

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

package/Runtime/Internal/Standalone/Web/Function.meta

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

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

@@ -0,0 +1,13 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public interface IWebTransmit
+    {
+        void Transparent(string functionName, string data);
+
+        void TransObserver(WebActionEnum type, Dictionary<string,object> dict);
+    }
+}
+#endif

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

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

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

@@ -0,0 +1,15 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class JsRequest
+    {
+        [JsonProperty("callbackId")] public string CallbackId { get; set; }
+
+        [JsonProperty("data")] public object Data { get; set; }
+
+        [JsonProperty("handlerName")] public string HandlerName { get; set; }
+    }
+}
+#endif

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

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

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

@@ -0,0 +1,17 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class JsResponse
+    {
+        [JsonProperty("responseId")] public string ResponseId {get;set;}
+
+        [JsonProperty("responseData")] public object ResponseData {get;set;}
+
+        public JsResponse()
+        {
+        }
+    }
+}
+#endif