From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- Client/Assets/Scripts/UniWebView/Readme.txt | 19 + Client/Assets/Scripts/UniWebView/Readme.txt.meta | 5 + Client/Assets/Scripts/UniWebView/Script.meta | 9 + .../Assets/Scripts/UniWebView/Script/Helper.meta | 9 + .../UniWebView/Script/Helper/UniWebViewHelper.cs | 91 ++ .../Script/Helper/UniWebViewHelper.cs.meta | 9 + .../Assets/Scripts/UniWebView/Script/UniWebView.cs | 1028 ++++++++++++++++++++ .../Scripts/UniWebView/Script/UniWebView.cs.meta | 9 + .../UniWebView/Script/UniWebViewEdgeInsets.cs | 55 ++ .../UniWebView/Script/UniWebViewEdgeInsets.cs.meta | 9 + .../Scripts/UniWebView/Script/UniWebViewMessage.cs | 87 ++ .../UniWebView/Script/UniWebViewMessage.cs.meta | 9 + .../UniWebView/Script/UniWebViewOrientation.cs | 12 + .../Script/UniWebViewOrientation.cs.meta | 9 + .../UniWebView/Script/UniWebViewTransitionEdge.cs | 31 + .../Script/UniWebViewTransitionEdge.cs.meta | 12 + Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip | Bin 0 -> 525384 bytes .../Scripts/UniWebView/ThirdPartyJar.zip.meta | 8 + Client/Assets/Scripts/UniWebView/UniWeb.cs | 589 +++++++++++ Client/Assets/Scripts/UniWebView/UniWeb.cs.meta | 12 + 20 files changed, 2012 insertions(+) create mode 100644 Client/Assets/Scripts/UniWebView/Readme.txt create mode 100644 Client/Assets/Scripts/UniWebView/Readme.txt.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script/Helper.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs create mode 100644 Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebView.cs create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebView.cs.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs.meta create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs create mode 100644 Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs.meta create mode 100644 Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip create mode 100644 Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip.meta create mode 100644 Client/Assets/Scripts/UniWebView/UniWeb.cs create mode 100644 Client/Assets/Scripts/UniWebView/UniWeb.cs.meta (limited to 'Client/Assets/Scripts/UniWebView') diff --git a/Client/Assets/Scripts/UniWebView/Readme.txt b/Client/Assets/Scripts/UniWebView/Readme.txt new file mode 100644 index 00000000..7a772134 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Readme.txt @@ -0,0 +1,19 @@ +## UniWebView - An easier solution for integrating WebView to your mobile games + +Thank you for purchasing UniWebView! + +To get started with this asset, we strongly suggest to open demo scenes to play +with the main features of UniWebView. You could use `0.Top` scene as a start point. +Once you get familiar with UniWebView and ready to publish your game, you could +feel free to remove the demo folder under UniWebView, to prevent the demo scripts +compiled to your game. + +For more information (including manual and script refernce), please visit our +officail website of UniWebView: http://uniwebview.onevcat.com + +If you encountered any problem when using UniWebView, please refer to our help +desk to get support: https://onevcat.zendesk.com + +Best regards. + +From UniWebView Team. diff --git a/Client/Assets/Scripts/UniWebView/Readme.txt.meta b/Client/Assets/Scripts/UniWebView/Readme.txt.meta new file mode 100644 index 00000000..a703c298 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Readme.txt.meta @@ -0,0 +1,5 @@ +fileFormatVersion: 2 +guid: 41f76c893d26c445d8762c1c8cb9d088 +TextScriptImporter: + userData: + assetBundleName: diff --git a/Client/Assets/Scripts/UniWebView/Script.meta b/Client/Assets/Scripts/UniWebView/Script.meta new file mode 100644 index 00000000..3078bfbe --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 687577cf7b4fedc4ba252385fd342bdc +folderAsset: yes +timeCreated: 1497248060 +licenseType: Pro +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/UniWebView/Script/Helper.meta b/Client/Assets/Scripts/UniWebView/Script/Helper.meta new file mode 100644 index 00000000..67841d99 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/Helper.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: fa57d53780777cd49a2c5b454fba02c6 +folderAsset: yes +timeCreated: 1497248060 +licenseType: Pro +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs b/Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs new file mode 100644 index 00000000..17e810b1 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs @@ -0,0 +1,91 @@ +using UnityEngine; + +/// +/// Supply some helper utility method for UniWebView +/// +public class UniWebViewHelper{ + /// + /// Get the height of the screen. + /// + /// + /// The height of screen. + /// + /// + /// In iOS devices, it will always return the screen height in "point", + /// instead of "pixel". It would be useful to use this value to calculate webview size. + /// On other platforms, it will just return Unity's Screen.height. + /// For example, a portrait iPhone 5 will return 568 and a landscape one 320. You should + /// always use this value to do screen-size-based insets calculation. + /// + public static int screenHeight { + get { +#if UNITY_IOS && !UNITY_EDITOR + return UniWebViewPlugin.ScreenHeight(); +#else + return Screen.height; +#endif + } + } + + /// + /// Get the height of the screen. + /// + /// + /// The height of screen. + /// + /// + /// In iOS devices, it will always return the screen width in "point", + /// instead of "pixel". It would be useful to use this value to calculate webview size. + /// On other platforms, it will just return Unity's Screen.height. + /// For example, a portrait iPhone 5 will return 320 and a landscape one 568. You should + /// always use this value to do screen-size-based insets calculation. + /// + public static int screenWidth { + get { +#if UNITY_IOS && !UNITY_EDITOR + return UniWebViewPlugin.ScreenWidth(); +#else + return Screen.width; +#endif + } + } + + /// + /// Get the screen scale. In iOS or OS X Editor, it could be 1, 2 or 3 now, depending on the type of your screen. + /// + /// The screen scale. + public static int screenScale { + get { +#if UNITY_IOS || UNITY_EDITOR + return UniWebViewPlugin.ScreenScale(); +#else + return 1; +#endif + } + } + + /// + /// Get the local streaming asset path for a given file path related to the StreamingAssets folder. + /// + /// + /// This method will help you to concat a URL string for a file under your StreamingAssets folder for different platforms. + /// + /// The relative path to the Assets/StreamingAssets of your file. + /// For example, if you placed a html file under Assets/StreamingAssets/www/index.html, you should pass `www/demo.html` as parameter. + /// + /// The path you could use as the url for the web view. + public static string streamingAssetURLForPath(string path) + { +#if UNITY_EDITOR + return Application.streamingAssetsPath + "/" + path; +#elif UNITY_IOS + return Application.streamingAssetsPath + "/" + path; +#elif UNITY_ANDROID + return "file:///android_asset/" + path; +#elif UNITY_WP8 + return "Data/StreamingAssets/" + path; +#else + return string.Empty; +#endif + } +} diff --git a/Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs.meta b/Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs.meta new file mode 100644 index 00000000..33e5071d --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/Helper/UniWebViewHelper.cs.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 140fc92629361465289bcaf88e465b88 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebView.cs b/Client/Assets/Scripts/UniWebView/Script/UniWebView.cs new file mode 100644 index 00000000..fd591922 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebView.cs @@ -0,0 +1,1028 @@ +#if UNITY_IOS || UNITY_ANDROID || UNITY_WP8 +// +// UniWebView.cs +// Created by Wang Wei(@onevcat) on 2013-10-20. +// +using UnityEngine; +using System.Collections; +using System; + +/// +/// The main class of UniWebView. +/// +/// +/// Each gameObject with this script represent a webview object +/// in system. Be careful: when this script's Awake() get called, it will change the name of +/// the gameObject to make it unique in the game. So make sure this script is appeneded to a +/// gameObject that you don't care its name. +/// +public class UniWebView : MonoBehaviour { + #region Events and Delegate + //Delegate and event + public delegate void LoadCompleteDelegate(UniWebView webView, bool success, string errorMessage); + /// + /// Occurs when a UniWebView finished loading a webpage. + /// + /// + /// If loading finished successfully, success will be true, otherwise false and with an errorMessage. + /// + public event LoadCompleteDelegate OnLoadComplete; + + public delegate void LoadBeginDelegate(UniWebView webView, string loadingUrl); + /// + /// Occurs when a UniWebView began to load a webpage. + /// + /// + /// You can do something with the UniWebView passed by parameter to get some info + /// or do your things when a url begins to load + /// Sometimes, the webpage contains some other parts besides of the main frame. Whenever these parts + /// begin to load, this event will be fired. You can get the url from parameter to know what url is + /// about to be loaded. + /// It is useful when you want to get some parameters from url when user clicked a link. + /// + public event LoadBeginDelegate OnLoadBegin; + + public delegate void ReceivedMessageDelegate(UniWebView webView, UniWebViewMessage message); + /// + /// Occurs when a UniWebView received message. + /// + /// + /// If a url with format of "uniwebview://yourPath?param1=value1¶m2=value2" clicked, + /// this event will get raised with a object. + /// + public event ReceivedMessageDelegate OnReceivedMessage; + + public delegate void EvalJavaScriptFinishedDelegate(UniWebView webView, string result); + /// + /// Occurs when a UniWebView finishes eval a javascript and returned something. + /// + /// + /// You can use EvaluatingJavaScript method to make the webview to eval a js. + /// The string-returned version of EvaluatingJavaScript is removed. You should + /// always listen this event to get the result of js. + /// + public event EvalJavaScriptFinishedDelegate OnEvalJavaScriptFinished; + + public delegate bool WebViewShouldCloseDelegate(UniWebView webView); + /// + /// Occurs when on web view will be closed by native. Ask if this webview should be closed or not. + /// + /// The users can close the webView by tapping back button (Android) or done button (iOS). + /// When the webview will be closed, this event will be raised. + /// If you return false, the webview will not be closed. If you did not implement it, webview will be closed. + /// + public event WebViewShouldCloseDelegate OnWebViewShouldClose; + + public delegate void ReceivedKeyCodeDelegate(UniWebView webView, int keyCode); + /// + /// Occurs when users clicks or taps any key while webview is actived. This event only fired on Android. + /// + /// + /// On Android, the key down event can not be passed back to Unity due to some issue in Unity 4.3's Android Player. + /// As result, you are not able to get the key input on Android by just using Unity's Input.GetKeyDown or GetKey method. + /// If you want to know the user input while the webview on, you can subscribe this event. + /// This event will be fired with a int number indicating the key code tapped as parameter. + /// You can refer to Android's documentation to find out which key is tapped (http://developer.android.com/reference/android/view/KeyEvent.html) + /// This event will be never raised on iOS, because iOS forbids the tracking of user's keyboard or device button events. + /// + public event ReceivedKeyCodeDelegate OnReceivedKeyCode; + + public delegate UniWebViewEdgeInsets InsetsForScreenOreitationDelegate(UniWebView webView, UniWebViewOrientation orientation); + /// + /// Called when the webview need to know the insets for calculating webview's frame. + /// + /// + /// If you need to show web content in both portrait and landscpace mode, you might want to + /// specify different insets for the screen orientation separately. + /// This event will be called when the Show() method gets called and the screen orientation + /// changes. You can implement this method and check current orientation, then return correct insets. + /// If this event is not implemented, the old insets value will be used to resize the webview size. + /// If you do not use auto-rotating in your webview, you can ignore this method and just set the + /// property directly. + /// + public event InsetsForScreenOreitationDelegate InsetsForScreenOreitation; + + #endregion + + [SerializeField] + private UniWebViewEdgeInsets _insets = new UniWebViewEdgeInsets(0,0,0,0); + + /// + /// Gets or sets the insets of a UniWebView object. + /// + /// The insets in point from top, left, bottom and right edge from the screen. + /// + /// Default value is UniWebViewEdgeInsets(0,0,0,0), which means a full screen webpage. + /// If you want use different insets in portrait and landscape screen, use + /// + public UniWebViewEdgeInsets insets { + get { + return _insets; + } + set { + if (_insets != value) { + ForceUpdateInsetsInternal(value); + } + } + } + + private void ForceUpdateInsetsInternal(UniWebViewEdgeInsets insets) { + _insets = insets; + UniWebViewPlugin.ChangeInsets(gameObject.name, + this.insets.top, + this.insets.left, + this.insets.bottom, + this.insets.right); + #if UNITY_EDITOR + CreateTexture(this.insets.left, + this.insets.bottom, + Screen.width - this.insets.left - this.insets.right, + Screen.height - this.insets.top - this.insets.bottom + ); + #endif + } + + /// + /// The url this UniWebView should load. You should set it before loading webpage. + /// Do not use this value when you want to get the url of current page. It is only for loading the first page. + /// The value will not change as the users navigating between the pages. + /// Use if you want to know current url. + /// + public string url; + + /// + /// If true, load the set url when in script's Start() method. + /// Otherwise, you should call Load() method yourself. + /// + public bool loadOnStart; + + /// + /// If true, show the webview automatically when it finished loading. + /// Otherwise, you should listen the OnLoadComplete event and call Show() method your self. + /// + public bool autoShowWhenLoadComplete; + + /// + /// Gets the current URL of the web page. + /// + /// The current URL of this webview. + /// + /// This value indicates the main frame url of the webpage. + /// It will be updated only when the webpage finishs or fails loading. + /// + public string currentUrl { + get { + return UniWebViewPlugin.GetCurrentUrl(gameObject.name); + } + } + + private bool _backButtonEnable = true; + private bool _bouncesEnable; + private bool _zoomEnable; + private string _currentGUID; + private int _lastScreenHeight; + private bool _immersiveMode = true; + + private Action _showTransitionAction = null; + private Action _hideTransitionAction = null; + + /// + /// Gets or sets a value indicating whether the back button of this is enabled. + /// + /// + /// It is only for Android and Windows Phone 8. If set true, users can use the back button of these devices to goBack or close the web view + /// if there is nothing to goBack. Otherwise, the back button will do nothing when the webview is shown. + /// When set true, Unity will not receive the Input.KeyDown or other similar event in Android. You could use to watch the key event instead. + /// This value means nothing for iOS, since there is no back button for iOS devices. + /// + /// true if back button enabled; otherwise, false. Default is true. + public bool backButtonEnable { + get { + return _backButtonEnable; + } + set { + if (_backButtonEnable != value) { + _backButtonEnable = value; + #if (UNITY_ANDROID || UNITY_WP8) && !UNITY_EDITOR + UniWebViewPlugin.SetBackButtonEnable(gameObject.name, _backButtonEnable); + #endif + } + } + } + + /// + /// Gets or sets a value indicating whether this can bounces or not. + /// + /// + /// The default iOS webview has a bounces effect when drag out of edge. + /// The default Android webview has a color indicator when drag beyond the edge. + /// UniWebView disabled these bounces effect by default. If you want the bounces, set this property to true. + /// This property does noting in editor or Windows Phone 8. + /// + /// true if bounces enable; otherwise, false. + public bool bouncesEnable { + get { + return _bouncesEnable; + } + set { + if (_bouncesEnable != value) { + _bouncesEnable = value; + #if !UNITY_EDITOR + UniWebViewPlugin.SetBounces(gameObject.name, _bouncesEnable); + #endif + } + } + } + + /// + /// Gets or sets a value indicating whether this can be zoomed or not. + /// + /// + /// If true, users can zoom in or zoom out the webpage by a pinch gesture. + /// This propery will valid immediately on Android. But on iOS, it will not valid until the next page loaded. + /// You can set this property before page loading, or use Reload() to refresh current page to make it valid. + /// This property does noting in Windows Phone 8, since there is no way to control the default behavior for it. + /// If you need to disable users zoom or pinch guesture, you need to add a viewport tag with "user-scalable=no" to your page. + /// + /// true if zoom enabled; otherwise, false. Default is false. + public bool zoomEnable { + get { + return _zoomEnable; + } + set { + if (_zoomEnable != value) { + _zoomEnable = value; + #if !UNITY_EDITOR + UniWebViewPlugin.SetZoomEnable(gameObject.name, _zoomEnable); + #endif + } + } + } + + /// + /// Get the user agent of this webview. + /// + /// The string of user agent using by the webview. + /// + /// It is a read-only property of webview. Once it is set when the webview gets created, the user agent can not be changed again. + /// If you want to use a customized user agent, you should call method before create a webview component. + /// + public string userAgent { + get { + return UniWebViewPlugin.GetUserAgent(gameObject.name); + } + } + + /// + /// Get or set the alpha of current webview. + /// + /// The alpha. + /// + /// This value indicates the alpha of webview. + /// The value should be between 0.0~1.0, which 1.0 means opaque and 0.0 is transparent. + /// This property will work on iOS, Android and WP8. In editor it will be always 1.0 and opaque. + /// + public float alpha { + get { + return UniWebViewPlugin.GetAlpha(gameObject.name); + } + set { + UniWebViewPlugin.SetAlpha(gameObject.name, Mathf.Clamp01(value)); + } + } + + /// + /// Whether the new page should be opened in an external browser when user clicks a link. + /// + /// A boolean indicates link clicking should be opened externally or not. + /// + /// If true, when user clicks on a link, an external web page browser on the device will be opened + /// and direct to the target link. It will be useful if you need navigate your user to a device installed + /// browser (like Mobile Safari on iOS or Chrome on Android). + /// This will only work when your user click a link in your page. Due to the lack detection of Android web view, + /// some javascript embedded link will not be able to open externally correctly. If you need more control of it, + /// consider to add all http/https scheme with AddUrlScheme method and handle them case by case in the OnReceivedMessage callback. + /// The default value is false, which means all link clicking will be opened in place. + /// + public bool openLinksInExternalBrowser { + get { + return UniWebViewPlugin.GetOpenLinksInExternalBrowser(gameObject.name); + } + set { + UniWebViewPlugin.SetOpenLinksInExternalBrowser(gameObject.name, value); + } + } + + /// + /// Get or set a value indicating whether this is in immersive mode. + /// + /// true if immersive mode; otherwise, false. + /// + /// + /// + public bool immersiveMode { + get { + return _immersiveMode; + } + set { + #if UNITY_ANDROID && !UNITY_EDITOR + _immersiveMode = value; + UniWebViewPlugin.SetImmersiveModeEnabled(gameObject.name, _immersiveMode); + #endif + } + } + + /// + /// Set user agent string for webview. This method has no effect on the webviews which are already initiated. + /// The user agent of a UniWebView component can not be changed once it is created. + /// If you want to change the user agent for the webview, you have to call it before creating the UniWebView instance. + /// + /// The value user agent should be. Set it to null will reset the user agent to the default one. + public static void SetUserAgent(string value) { + UniWebViewPlugin.SetUserAgent(value); + } + + /// + /// Reset the user agent of webview. This method has no effect on the webviews which are already initiated. + /// The user agent of a UniWebView component can not be changed once it is created. + /// If you want to set user agent, use the method. + /// + public static void ResetUserAgent() { + SetUserAgent(null); + } + + /// + /// Set the text in Done button of tool bar in iOS. + /// User could use this button in iOS to close the web view. By default, "Done" will be shown for this button. + /// If you want to change the text of tool bar done button for the webview, you have to call it before creating the UniWebView instance. + /// This method only works for iOS. See . + /// + /// The text you want to show for the Done button. Set it to null will reset it to "Done". + public static void SetDoneButtonText(string text) { + #if UNITY_IOS && !UNITY_EDITOR + UniWebViewPlugin.SetDoneButtonText(text); + #endif + } + + /// + /// Load the url set in property of this UniWebView. + /// + public void Load() { + string loadUrl = String.IsNullOrEmpty(url) ? "about:blank" : url.Trim(); + UniWebViewPlugin.Load(gameObject.name, loadUrl); + } + + /// + /// A alias method to load a specified url. + /// + /// A url to set and load + /// + /// It will set the url of this UniWebView and then call Load it. + /// + public void Load(string aUrl) { + url = aUrl; + Load(); + } + + /// + /// Load a HTML string. + /// + /// The content HTML string for the web page. + /// The base URL in which the webview should to refer other resources + /// + /// If you want to specify a local baseUrl, you need to encode it to proper format. + /// See the "Can I load some html string by using UniWebView?" section in FAQ page (http://uniwebview.onevcat.com/faqs.html) for more. + /// + public void LoadHTMLString(string htmlString, string baseUrl) { + UniWebViewPlugin.LoadHTMLString(gameObject.name, htmlString, baseUrl); + } + + /// + /// Reload current page. + /// + public void Reload() { + UniWebViewPlugin.Reload(gameObject.name); + } + + /// + /// Stop loading the current request. It will do nothing if the webpage is not loading. + /// + public void Stop() { + UniWebViewPlugin.Stop(gameObject.name); + } + + /// + /// Show this UniWebView on screen. + /// + /// + /// Usually, it should be called when you get the LoadCompleteDelegate raised with a success flag true. + /// The webview will not be visible until this method is called. + /// + public void Show(bool fade = false, UniWebViewTransitionEdge direction = UniWebViewTransitionEdge.None, float duration = 0.4f, Action finishAction = null) { + _lastScreenHeight = UniWebViewHelper.screenHeight; + ResizeInternal(); + + UniWebViewPlugin.Show(gameObject.name, fade, (int)direction, duration); + _showTransitionAction = finishAction; + + if (toolBarShow) { + ShowToolBar(true); + } + + #if UNITY_EDITOR + _webViewId = UniWebViewPlugin.GetId(gameObject.name); + _hidden = false; + #endif + } + + /// + /// Hide this UniWebView. + /// + /// + /// Calling this method on a UniWebView will hide it. + /// + public void Hide(bool fade = false, UniWebViewTransitionEdge direction = UniWebViewTransitionEdge.None, float duration = 0.4f, Action finishAction = null) { + #if UNITY_EDITOR + _hidden = true; + #endif + UniWebViewPlugin.Hide(gameObject.name, fade, (int)direction, duration); + _hideTransitionAction = finishAction; + } + + + /// + /// Send a piece of javascript to the web page and evaluate (execute) it. + /// + /// A single javascript method call to be sent to and executed in web page + /// + /// Although you can write complex javascript code and evaluate it at once, a suggest way is calling this method with a single js method name. + /// The webview will try evaluate (execute) the javascript. When it finished, OnEvalJavaScriptFinished will be raised with the result. + /// You can add your js function to the html page by referring to the js file in your html page, or add it by using AddJavaScript(string javaScript) method. + /// + public void EvaluatingJavaScript(string javaScript) { + UniWebViewPlugin.EvaluatingJavaScript(gameObject.name, javaScript); + } + + /// + /// Add some javascript to the web page. + /// + /// Some javascript code you want to add to the page. + /// + /// This method will execute the input javascript code without raising an + /// OnEvalJavaScriptFinished event. You can use this method to add some customized js + /// function to the web page, then use EvaluatingJavaScript(string javaScript) to execute it. + /// This method will add js in a async way in Android, so you should call it earlier than EvaluatingJavaScript + /// + public void AddJavaScript(string javaScript) { + UniWebViewPlugin.AddJavaScript(gameObject.name, javaScript); + } + + /// + /// Clean the cache of this UniWebView. + /// + public void CleanCache() { + UniWebViewPlugin.CleanCache(gameObject.name); + } + + /// + /// Clean the cookie using in the app. + /// + /// The key under which you want to clean the cache. + /// + /// Try to clean cookies under the specified key using in the app. + /// If you leave the key as null or send an empty string as key, all cache will be cleared. + /// This method will clear the cookies in memory and try to + /// sync the change to disk. The memory opreation will return + /// right away, but the disk operation is async and could take some time. + /// Caution, in Android, there is no way to remove a specified cookie. + /// So this method will call setCookie method with the key to set + /// it to an empty value instead. Please refer to Android + /// documentation on CookieManager for more information. + /// The key parameter will be ignored at all on Windows Phone 8. All cookie will be cleared. + /// + public void CleanCookie(string key = null) { + UniWebViewPlugin.CleanCookie(gameObject.name, key); + } + + /// + /// Set the background of webview to transparent. + /// + /// + /// In iOS, there is a grey background in webview. If you don't want it, just call this method to set it transparent. + /// There is no way to set Windows Phone 8 background to transparent, so this method will do noting on Windows Phone. + /// + [Obsolete("SetTransparentBackground is deprecated, please use SetBackgroundColor instead.")] + public void SetTransparentBackground(bool transparent = true) { + UniWebViewPlugin.TransparentBackground(gameObject.name, transparent); + } + + /// + /// Set the background color of webview. + /// + /// + /// Set the background color of the webview. In iOS, it will only take in action when the web page has no background color from css. + /// There is no way to set Windows Phone 8, so this method will do noting on Windows Phone. + /// And in OSX Editor, it is limited and can be only used to set white or clear background. + /// + public void SetBackgroundColor(Color color) { + UniWebViewPlugin.SetBackgroundColor(gameObject.name, color.r, color.g, color.b, color.a); + } + + /// + /// If the tool bar is showing or not. + /// + /// + /// This parameter is only available in iOS. In other platform, it will be always false. + /// It will take no effect when you set this after you call Show on the webview. Use `ShowToolBar` and `HideToolBar` instead if the webview is already showing. + /// + public bool toolBarShow = false; + + /// + /// Show the tool bar. The tool bar contains three buttons: go back, go forward and close webview. + /// + /// If set to true, show it with an animation. + /// + /// The tool bar is only available in iOS. In Android and Windows Phone, you can use the back button of device to go back. + /// + public void ShowToolBar(bool animate) { + #if UNITY_IOS && !UNITY_EDITOR + toolBarShow = true; + UniWebViewPlugin.ShowToolBar(gameObject.name,animate); + #endif + } + + /// + /// Hide the tool bar. The tool bar contains three buttons: go back, go forward and close webview. + /// + /// If set to true, show it with an animation. + /// + /// The tool bar is only available in iOS. For Android and Windows Phone, you can use the back button of device to go back. + /// + public void HideToolBar(bool animate) { + #if UNITY_IOS && !UNITY_EDITOR + toolBarShow = false; + UniWebViewPlugin.HideToolBar(gameObject.name,animate); + #endif + } + + /// + /// Set if a default spinner should show when loading the webpage. + /// + /// + /// The default value is true, which means a spinner will show when the webview is on, and it is loading some thing. + /// The spinner contains a label and you can set a message to it. + /// You can set it false if you do not want a spinner show when loading. + /// A progress bar will be used in Windows Phone instead of a spinner. + /// + /// If set to true show. + public void SetShowSpinnerWhenLoading(bool show) { + UniWebViewPlugin.SetSpinnerShowWhenLoading(gameObject.name, show); + } + + /// + /// Set the label text for the spinner showing when webview loading. + /// The default value is "Loading..." + /// + /// Text. + /// + /// There is no text for Windows Phone spinner, so it will do noting for it. + /// + public void SetSpinnerLabelText(string text) { + UniWebViewPlugin.SetSpinnerText(gameObject.name, text); + } + + /// + /// Set to use wide view port support or not. + /// + /// If set to true use view port tag in the html to determine the layout. + /// + /// This method only works (and be necessary) for Android. If you are using viewport tag in you page, you may + /// want to enable it before you loading and showing your page. + /// + public void SetUseWideViewPort(bool use) { + #if UNITY_ANDROID && !UNITY_EDITOR + UniWebViewPlugin.SetUseWideViewPort(gameObject.name, use); + #endif + } + + /// + /// Set to load with overview mode or not. + /// + /// + /// If set to true, use overview mode to load the page. + /// + /// + /// This method only works for Android. If you need to load your page with overview mode, you may + /// want to enable it before you loading and showing your page. + /// + public void LoadWithOverviewMode(bool overview) { + #if UNITY_ANDROID && !UNITY_EDITOR + UniWebViewPlugin.LoadWithOverviewMode(gameObject.name, overview); + #endif + } + + /// + /// Determines whether the webview can go back. + /// + /// true if this instance can go back, which means there is at least one page in the navigation stack below; + /// otherwise, false. + public bool CanGoBack() { + return UniWebViewPlugin.CanGoBack(gameObject.name); + } + + /// + /// Determines whether this webview can go forward. + /// + /// true if this instance can go forward, which means the user did at least once back; + /// otherwise, false. + public bool CanGoForward() { + return UniWebViewPlugin.CanGoForward(gameObject.name); + } + + /// + /// Go to the previous page if there is any one. + /// + public void GoBack() { + UniWebViewPlugin.GoBack(gameObject.name); + } + + /// + /// Go to the next page if there is any one. + /// + public void GoForward() { + UniWebViewPlugin.GoForward(gameObject.name); + } + + /// + /// Add a url to white list of permission request trust sites. + /// + /// + /// This method only works in Android. In Android, if you request audio or video accessibility from web page, + /// you should add the site url to a white list by using this method, or it will not be granted to use those protected resources. + /// There is no need to call it in iOS, and this method will do nothing in platforms other than Android. + /// For more about Android protected permission, see https://developer.android.com/reference/android/webkit/PermissionRequest.html. + /// + /// URL. + public void AddPermissionRequestTrustSite(string url) { + #if UNITY_ANDROID && !UNITY_EDITOR + UniWebViewPlugin.AddPermissionRequestTrustSite(gameObject.name, url); + #endif + } + + /// + /// Adds the URL scheme. After be added, all link of this scheme will send a message when clicked. + /// + /// Scheme. + /// + /// The scheme should not contain "://". For example, if you want to receive a url like "xyz://mydomian.com", you can pass "xyz" here. + /// + public void AddUrlScheme(string scheme) { + UniWebViewPlugin.AddUrlScheme(gameObject.name, scheme); + } + + /// + /// Removes the URL scheme. After be removed, this kind of url will be handled by the webview. + /// + /// Scheme. + public void RemoveUrlScheme(string scheme) { + UniWebViewPlugin.RemoveUrlScheme(gameObject.name, scheme); + } + + /// + /// Set the header field. + /// + /// + /// Specify customized header field for the next url loading. + /// You could call this method multiple times to add key/value pairs for different fields. + /// Only the requests by using Load() method of current web view will use these setting for header. + /// + /// Key of the header field. Empty string or null will be ignored. + /// Value of the header field. Pass null to remove an existing value. Empty string will be ignored. + public void SetHeaderField(string key, string value) { + #if UNITY_WP8 + Debug.LogWarning("Not implemented for Windows Phone 8."); + #else + UniWebViewPlugin.SetHeaderField(gameObject.name, key, value); + #endif + } + + /// + /// Set visibility of vertical bar for the web view. + /// + /// + /// This method will not work for editor and Windows Phone 8. + /// + /// Whether the vertical scroll bar should be visible or not when the web view is being scrolled. + public void SetVerticalScrollBarShow(bool show) { + #if UNITY_WP8 + Debug.LogWarning("Not implemented for Windows Phone 8."); + #else + UniWebViewPlugin.SetVerticalScrollBarShow(gameObject.name, show); + #endif + } + + /// + /// Set visibility of horizontal bar for the web view. + /// + /// + /// This method will not work for editor and Windows Phone 8. + /// + /// Whether the horizontal scroll bar should be visible or not when the web view is being scrolled. + public void SetHorizontalScrollBarShow(bool show) { + #if UNITY_WP8 + Debug.LogWarning("Not implemented for Windows Phone 8."); + #else + UniWebViewPlugin.SetHorizontalScrollBarShow(gameObject.name, show); + #endif + } + + /// + /// Set web content could be debug or not. Only works for Android. + /// + /// + /// You can enable Remote Debugging for Android devices by calling this method and passing true. See Google's + /// Remote Debugging Android Devices documentation for more about it. + /// https://developers.google.com/web/tools/chrome-devtools/debug/remote-debugging/remote-debugging + /// + /// This method will do nothing for iOS or editor. + /// + /// Whether this page could be debug or not. + public static void SetWebContentsDebuggingEnabled(bool enabled) { + #if UNITY_ANDROID && !UNITY_EDITOR + UniWebViewPlugin.SetWebContentsDebuggingEnabled(enabled); + #endif + } + + private bool OrientationChanged() { + int newHeight = UniWebViewHelper.screenHeight; + if (_lastScreenHeight != newHeight) { + _lastScreenHeight = newHeight; + return true; + } else { + return false; + } + } + + + public void ForceResize() + { + ResizeInternal(); + } + + private void ResizeInternal() { + int newHeight = UniWebViewHelper.screenHeight; + int newWidth = UniWebViewHelper.screenWidth; + + UniWebViewEdgeInsets newInset = this.insets; + if (InsetsForScreenOreitation != null) { + UniWebViewOrientation orientation = + newHeight >= newWidth ? UniWebViewOrientation.Portrait : UniWebViewOrientation.LandScape; + newInset = InsetsForScreenOreitation(this, orientation); + } + + ForceUpdateInsetsInternal(newInset); + } + + #region Messages from native + public void LoadWebViewComplete(string message) + { + LoadComplete(message); + } + + private void LoadComplete(string message) { + bool loadSuc = string.Equals(message, ""); + bool hasCompleteListener = (OnLoadComplete != null); + + if (loadSuc) { + if (hasCompleteListener) { + OnLoadComplete(this, true, null); + } + if (autoShowWhenLoadComplete) { + Show(); + } + } else { + Debug.LogWarning("Web page load failed: " + gameObject.name + "; url: " + url + "; error:" + message); + +#if UNITY_EDITOR + if (message.Contains("App Transport Security")) { + Debug.LogWarning("It seems that ATS is enabled in Editor. You can not load http pages when it is on. Please visit our help center for more information: https://onevcat.zendesk.com/hc/en-us/articles/215527307-I-cannot-open-the-web-page-in-Unity-Editor-"); + } +#endif + if (hasCompleteListener) { + OnLoadComplete(this, false, message); + } + } + } + + private void LoadBegin(string url) { + if (OnLoadBegin != null) { + OnLoadBegin(this, url); + } + } + + private void ReceivedMessage(string rawMessage) { + UniWebViewMessage message = new UniWebViewMessage(rawMessage); + if (OnReceivedMessage != null) { + OnReceivedMessage(this,message); + } + } + + private void WebViewDone(string message) { + bool destroy = true; + if (OnWebViewShouldClose != null) { + destroy = OnWebViewShouldClose(this); + } + + if (destroy) { + Hide(); + Destroy(this); + } + } + + private void WebViewKeyDown(string message) { + int keyCode = Convert.ToInt32(message); + if (OnReceivedKeyCode != null) { + OnReceivedKeyCode(this, keyCode); + } + } + + private void EvalJavaScriptFinished(string result) { + if (OnEvalJavaScriptFinished != null) { + OnEvalJavaScriptFinished(this, result); + } + } + + private void AnimationFinished(string identifier) { + + } + + private void ShowTransitionFinished(string message) { + if (_showTransitionAction != null) { + _showTransitionAction(); + _showTransitionAction = null; + } + } + + private void HideTransitionFinished(string message) { + if (_hideTransitionAction != null) { + _hideTransitionAction(); + _hideTransitionAction = null; + } + } + + private IEnumerator LoadFromJarPackage(string jarFilePath) { + WWW stream = new WWW(jarFilePath); + yield return stream; + if (stream.error != null) { + if (OnLoadComplete != null) { + OnLoadComplete(this,false,stream.error); + } + yield break; + } else { + LoadHTMLString(stream.text, ""); + } + } + + #endregion + + #region Life Cycle + void Awake() { + _currentGUID = System.Guid.NewGuid().ToString(); + gameObject.name = gameObject.name + _currentGUID; + UniWebViewPlugin.Init(gameObject.name, + this.insets.top, + this.insets.left, + this.insets.bottom, + this.insets.right); + _lastScreenHeight = UniWebViewHelper.screenHeight; + + #if UNITY_EDITOR + _screenScale = UniWebViewHelper.screenScale; + CreateTexture(this.insets.left, + this.insets.bottom, + Screen.width - this.insets.left - this.insets.right, + Screen.height - this.insets.top - this.insets.bottom + ); + #endif + } + + void Start() { + if (loadOnStart) { + Load(); + } + } + + private void OnDestroy() { + #if UNITY_EDITOR + Clean(); + #endif + + RemoveAllListeners(); + + UniWebViewPlugin.Destroy(gameObject.name); + gameObject.name = gameObject.name.Replace(_currentGUID, ""); + } + + private void RemoveAllListeners() { + this.OnLoadBegin = null; + this.OnLoadComplete = null; + this.OnReceivedMessage = null; + this.OnReceivedKeyCode = null; + this.OnEvalJavaScriptFinished = null; + this.OnWebViewShouldClose = null; + this.InsetsForScreenOreitation = null; + } + + #endregion + + private void Update() { + #if UNITY_EDITOR + if (Application.platform == RuntimePlatform.OSXEditor) { + if (_webViewId != 0 && !_hidden) { + if (Input.GetKeyDown(KeyCode.Escape)) { + if (UniWebViewPlugin.CanGoBack(gameObject.name)) { + UniWebViewPlugin.GoBack(gameObject.name); + } else { + WebViewDone(""); + } + } else { + _inputString += Input.inputString; + } + } + } + #endif + + //Handle screen auto orientation. + if (OrientationChanged()) { + ResizeInternal(); + } + } + + #region UnityEditor Debug + #if UNITY_EDITOR + private Rect _webViewRect; + private Texture2D _texture; + private string _inputString; + private int _webViewId; + private bool _hidden; + private IntPtr _renderCallback; + private int _screenScale; + + private void CreateTexture(int x, int y, int width, int height) { + if (Application.platform == RuntimePlatform.OSXEditor) { + _webViewRect = new Rect(x, y, width, height); + _texture = new Texture2D(width * 2, height * 2, TextureFormat.ARGB32, false); + _texture = new Texture2D(width * _screenScale, height * _screenScale, TextureFormat.ARGB32, false); + } + } + + private void Clean() { + if (Application.platform == RuntimePlatform.OSXEditor) { + Destroy(_texture); + _webViewId = 0; + _texture = null; + } + } + + private void OnGUI() + { + if (Application.platform == RuntimePlatform.OSXEditor) { + if (_webViewId != 0 && !_hidden) { + Vector3 pos = Input.mousePosition; + bool down = Input.GetMouseButton(0); + bool press = Input.GetMouseButtonDown(0); + bool release = Input.GetMouseButtonUp(0); + float deltaY = Input.GetAxis("Mouse ScrollWheel"); + bool keyPress = false; + string keyChars = ""; + short keyCode = 0; + if (!string.IsNullOrEmpty(_inputString)) { + keyPress = true; + keyChars = _inputString.Substring(0, 1); + keyCode = (short)_inputString[0]; + _inputString = _inputString.Substring(1); + } + + var id = _texture.GetNativeTexturePtr().ToInt32(); + UniWebViewPlugin.InputEvent(gameObject.name, + (int)(pos.x - _webViewRect.x), (int)(pos.y - _webViewRect.y), deltaY, + down, press, release, keyPress, keyCode, keyChars, + id); +#if UNITY_5_0 || UNITY_5_1 || UNITY_5_2_0 + GL.IssuePluginEvent(_webViewId); +#else + + GL.IssuePluginEvent(UniWebViewPlugin.GetRenderEventFunc(), _webViewId); +#endif + Matrix4x4 m = GUI.matrix; + GUI.matrix = Matrix4x4.TRS(new Vector3(0, Screen.height, 0), + Quaternion.identity, new Vector3(1, -1, 1)); + GUI.DrawTexture(_webViewRect, _texture); + GUI.matrix = m; + } + } + } + #endif + #endregion +} +#endif //UNITY_IOS || UNITY_ANDROID diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebView.cs.meta b/Client/Assets/Scripts/UniWebView/Script/UniWebView.cs.meta new file mode 100644 index 00000000..385b2b90 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebView.cs.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 2a9fa304a8f3e4a829df11f36289fdc3 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs b/Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs new file mode 100644 index 00000000..88cb8755 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs @@ -0,0 +1,55 @@ +// +// UniWebViewEdgeInsets.cs +// Created by Wang Wei(@onevcat) on 2013-10-20. +// + +[System.Serializable] +/// +/// This class defined the edge inset of a UniWebView +/// +public class UniWebViewEdgeInsets { + + public int top, left, bottom, right; + + /// + /// Initializes a new instance of the class. + /// + /// Top inset by point. + /// Left inset by point. + /// Bottominset by point. + /// Rightinset by point. + public UniWebViewEdgeInsets(int aTop, int aLeft, int aBottom, int aRight) { + top = aTop; + left = aLeft; + bottom = aBottom; + right = aRight; + } + + public static bool operator ==(UniWebViewEdgeInsets inset1, UniWebViewEdgeInsets inset2) + { + return inset1.Equals(inset2); + } + + public static bool operator !=(UniWebViewEdgeInsets inset1, UniWebViewEdgeInsets inset2) + { + return !inset1.Equals(inset2); + } + + public override int GetHashCode() + { + var calculation = top + left + bottom + right; + return calculation.GetHashCode(); + } + + public override bool Equals (object obj) + { + if (obj == null || GetType() != obj.GetType()) { + return false; + } + UniWebViewEdgeInsets anInset = (UniWebViewEdgeInsets)obj; + return (top == anInset.top) && + (left == anInset.left) && + (bottom == anInset.bottom) && + (right == anInset.right); + } +} diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs.meta b/Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs.meta new file mode 100644 index 00000000..07f4e238 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewEdgeInsets.cs.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 070d3680690c740efb440eb36c6afa09 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs b/Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs new file mode 100644 index 00000000..b9a2f225 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs @@ -0,0 +1,87 @@ +// +// UniWebViewMessage.cs +// Created by Wang Wei(@onevcat) on 2013-10-20. +// +using System.Collections.Generic; +using UnityEngine; + +/// +/// This structure represent a message from webview. +/// +/// +/// All url with a scheme of "uniwebview" in the webpage clicked will raise +/// the OnReceivedMessage with a UniWebViewMessage object. You can listen to +/// that event and get path and param from webpage. +/// +public struct UniWebViewMessage { + /// + /// Gets the raw message. + /// + /// + /// The raw message received from UniWebView. It should be a url containing information + /// delivered from webview. + /// + public string rawMessage {get; private set;} + + /// + /// The url scheme of this UniWebViewMessage + /// + /// The scheme. + /// + /// Every message UniWebView can get is a url in a registered scheme. + /// The default scheme is "uniwebview". You can register your own scheme by + /// using the RegisterScheme method on UniWebView object. + /// + public string scheme {get; private set;} + + /// + /// The path of this UniWebViewMessage + /// + /// The path. + /// + /// A url "uniwebview://yourPath?param1=value1¶m2=value2", path = yourPath + /// + public string path {get; private set;} + + /// + /// The arguments of this UniWebViewMessage + /// + /// The arguments. + /// + /// A url "uniwebview://yourPath?param1=value1¶m2=value2", args[param1] = value1, args[param2] = value2 + /// + public Dictionary args{get; private set;} + + /// + /// Initializes a new instance of the struct. + /// + /// Raw message which will be parsed to a UniWebViewMessage. + public UniWebViewMessage(string rawMessage) : this() { + this.rawMessage = rawMessage; + string[] schemeSplit = rawMessage.Split(new string[] {"://"}, System.StringSplitOptions.None); + if (schemeSplit.Length >= 2) { + this.scheme = schemeSplit[0]; + string pathAndArgsString = ""; + int index = 1; + while (index < schemeSplit.Length) { + pathAndArgsString = string.Concat(pathAndArgsString, schemeSplit[index]); + index++; + } + + string[] split = pathAndArgsString.Split("?"[0]); + + this.path = split[0].TrimEnd('/'); + this.args = new Dictionary(); + if (split.Length > 1) { + foreach (string pair in split[1].Split("&"[0])) { + string[] elems = pair.Split("="[0]); + if (elems.Length > 1) { + args[elems[0]] = WWW.UnEscapeURL(elems[1]); + } + } + } + } else { + Debug.LogError("Bad url scheme. Can not be parsed to UniWebViewMessage: " + rawMessage); + } + } +} \ No newline at end of file diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs.meta b/Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs.meta new file mode 100644 index 00000000..f17ab581 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewMessage.cs.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 241fb3bc494b043f6be899ec7ebc5c87 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs b/Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs new file mode 100644 index 00000000..3431794f --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs @@ -0,0 +1,12 @@ +// +// UniWebViewOrientation.cs +// Created by Wang Wei(@onevcat) on 2014-10-7. +// +/// +/// The orientation of screen. If screen height larger than width, landscape. Otherwise, portrait. +/// +public enum UniWebViewOrientation +{ + Portrait, + LandScape +} diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs.meta b/Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs.meta new file mode 100644 index 00000000..62d08043 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewOrientation.cs.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 0189ece6d321b47c1a315290f463d8d6 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs b/Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs new file mode 100644 index 00000000..06fd3e56 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs @@ -0,0 +1,31 @@ +// +// UniWebViewTransitionEdge.cs +// Created by Wang Wei(@onevcat) on 2015-11-16. +// + +/// +/// Transition edges of webview. You can specify an edge in Show() or Hide() methods of web view. +/// +public enum UniWebViewTransitionEdge +{ + /// + /// No transition when showing or hiding. + /// + None = 0, + /// + /// Transit the web view from/to top. + /// + Top, + /// + /// Transit the web view from/to left. + /// + Left, + /// + /// Transit the web view from/to bottom. + /// + Bottom, + /// + /// Transit the web view from/to right. + /// + Right +} diff --git a/Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs.meta b/Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs.meta new file mode 100644 index 00000000..97174fb3 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/Script/UniWebViewTransitionEdge.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 88d71017250e84edab8ca0ddd686b55d +timeCreated: 1447685868 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip b/Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip new file mode 100644 index 00000000..bbad27bb Binary files /dev/null and b/Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip differ diff --git a/Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip.meta b/Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip.meta new file mode 100644 index 00000000..85aa78f1 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/ThirdPartyJar.zip.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 7e38bfa74a56c43588a3bc92c6753645 +timeCreated: 1428204772 +licenseType: Free +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/UniWebView/UniWeb.cs b/Client/Assets/Scripts/UniWebView/UniWeb.cs new file mode 100644 index 00000000..65467956 --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/UniWeb.cs @@ -0,0 +1,589 @@ +using UnityEngine; +using System.Collections; +using System.Collections.Generic; +using Assets.SDK; +using XUtliPoolLib; +using System; +using System.IO; + +/// +/// This is a demo script to show how to use UniWebView. +/// You can follow the step 1 to 10 and get started with the basic use of UniWebView. +/// +/// + + +public class UniWeb : MonoBehaviour +{ +#if UNITY_IOS || UNITY_ANDROID || UNITY_WP8 + +#if !DISABLE_JOYSDK + private JoyYouSDK _interface; +#endif + + private string mAppId = "1105309683"; + private string mOpenid = "0"; + private string mServerid = "0"; + private string mRoleid = "0"; + private string mToken = "0"; + private string mNickName = ""; + public static IUiUtility m_uiUtility; + private int _gap = 90; + ulong mOpenTime = 0; + string mWebViewUrl = "https://apps.game.qq.com/gts/gtp3.0/customize/dn/end.php"; + + //Just let it compile on platforms beside of iOS and Android + //If you are just targeting for iOS and Android, you can ignore this + + void Awake() + { +#if !DISABLE_JOYSDK + _interface = new JoyYouSDK(); +#endif + + m_uiUtility = XInterfaceMgr.singleton.GetInterface(XCommon.singleton.XHash("IUiUtility")); + } + + public void InitWebInfo(int platform, string openid, string serverid, string roleid, string nickname) + { + if (m_uiUtility == null) + m_uiUtility = XInterfaceMgr.singleton.GetInterface(XCommon.singleton.XHash("IUiUtility")); + + if (platform == 0) + mAppId = "1105309683"; + else + mAppId = "wxfdab5af74990787a"; + + mOpenid = openid; + mServerid = serverid; + mRoleid = roleid; + mNickName = nickname; + +#if !DISABLE_JOYSDK + string sdkconfig = ((IHuanlePlatform)_interface).GetSDKConfig("get_login_bill", ""); + +#if UNITY_EDITOR + Dictionary testinfo = new Dictionary(); + testinfo["token"] = "6859034BCE654365632252"; + testinfo["openid"] = "BAFE459486548AC698568956DEF"; + sdkconfig = MiniJSON.Json.Serialize(testinfo); +#endif + object obj = MiniJSON.Json.Deserialize(sdkconfig); + Dictionary info = obj as Dictionary; + + if (info != null) + { + if (info.ContainsKey("token")) + mToken = info["token"] as string ; + + if (info.ContainsKey("openid")) + mOpenid = info["openid"] as string; + } + + Debug.Log("The openid: " + mOpenid); + Debug.Log("The token: " + mToken); +#endif + } +#if UNITY_IOS || UNITY_ANDROID || UNITY_EDITOR + + //1. First of all, we need a reference to hold an instance of UniWebView + private UniWebView _webView; + + private string _errorMessage; + private GameObject _cube; + private Vector3 _moveVector; + private bool _is_bgopen = true; + + void Start() + { + + } + + public void OpenWebView() + { + Debug.Log("Will do open web view"); + + _gap = GetGap(); + + System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)); + mOpenTime = (ulong)(DateTime.Now - startTime).TotalMilliseconds; + + _webView = GetComponent(); + if (_webView == null) + { + _webView = gameObject.AddComponent(); + _webView.OnReceivedMessage += OnReceivedMessage; + _webView.OnLoadComplete += OnLoadComplete; + _webView.OnWebViewShouldClose += OnWebViewShouldClose; + _webView.OnEvalJavaScriptFinished += OnEvalJavaScriptFinished; + + _webView.InsetsForScreenOreitation += InsetsForScreenOreitation; + } + + string url = string.Format("{0}?appid={1}&openid={2}&access_token={3}&partition={4}&roleid={5}&entertime={6}&nickname={7}", + mWebViewUrl, mAppId, mOpenid, mToken, mServerid, mRoleid, mOpenTime, WWW.EscapeURL(mNickName)); + + Debug.Log("url: " + url); + + _webView.url = url; // WWW.EscapeURL(url); + + Debug.Log("Final url: " + _webView.url); + + Debug.Log("Width: " + Screen.width.ToString()); + Debug.Log("Height: " + Screen.height.ToString()); + //Debug.Log("Webview height: " + _webView.GetWebViewHeight().ToString()); + + _webView.Load(); + } + + public void CloseWebView(UniWebView webView) + { + if (webView == null) + webView = _webView; + + if (webView != null) + { + webView.CleanCache(); + webView.CleanCookie(); + webView.Hide(); + Destroy(webView); + webView.OnReceivedMessage -= OnReceivedMessage; + webView.OnLoadComplete -= OnLoadComplete; + webView.OnWebViewShouldClose -= OnWebViewShouldClose; + webView.OnEvalJavaScriptFinished -= OnEvalJavaScriptFinished; + webView.InsetsForScreenOreitation -= InsetsForScreenOreitation; + } + + _webView = null; + + _is_bgopen = true; + + if (m_uiUtility == null) + m_uiUtility = XInterfaceMgr.singleton.GetInterface(XCommon.singleton.XHash("IUiUtility")); + m_uiUtility.OnSetBg(true); + m_uiUtility.OnWebViewClose(); + } +#if UNITY_EDITOR + void Update() { + + if (Input.GetKeyUp(KeyCode.F10)) + { + string str = "uniwebview://webview?funcname=dnsetshareinfo&args=%7B%22title%22%3A%22%E5%88%86%E4%BA%AB%E6%B5%8B%E8%AF%95%E6%A0%87%E9%A2%98%22%2C%22desc%22%3A%22%E5%88%86%E4%BA%AB%E6%B5%8B%E8%AF%95%E6%8F%8F%E8%BF%B0%E6%8F%8F%E8%BF%B0%E6%8F%8F%E8%BF%B0%E3%80%82%E3%80%82%E3%80%82%E3%80%82%22%2C%22url%22%3A%22%2F%2Fiu.qq.com%2Fdn%2Fdist%2Fhtml%2Ftest.htm%22%2C%22imgurl%22%3A%22%2F%2Fgame.gtimg.cn%2Fimages%2Fiu%2Fdn%2Fb1.png%22%2C%22type%22%3A%22weixin%22%7D"; + if (_webView == null) _webView = gameObject.AddComponent(); + UniWebViewMessage message = new UniWebViewMessage(str); + OnReceivedMessage(_webView, message); + } + } +#endif + //5. When the webView complete loading the url sucessfully, you can show it. + // You can also set the autoShowWhenLoadComplete of UniWebView to show it automatically when it loads finished. + void OnLoadComplete(UniWebView webView, bool success, string errorMessage) { + if (success) { + webView.Show(); + } else { + Debug.Log("Something wrong in webview loading: " + errorMessage); + _errorMessage = errorMessage; + } + } + + //6. The webview can talk to Unity by a url with scheme of "uniwebview". See the webpage for more + // Every time a url with this scheme clicked, OnReceivedMessage of webview event get raised. + void OnReceivedMessage(UniWebView webView, UniWebViewMessage message) + { + Debug.Log("OnReceivedMessage"); + Debug.Log(message.rawMessage); + //7. You can get the information out from the url path and query in the UniWebViewMessage + //For example, a url of "uniwebview://move?direction=up&distance=1" in the web page will + //be parsed to a UniWebViewMessage object with: + // message.scheme => "uniwebview" + // message.path => "move" + // message.args["direction"] => "up" + // message.args["distance"] => "1" + // "uniwebview" scheme is sending message to Unity by default. + // If you want to use your customized url schemes and make them sending message to UniWebView, + // use webView.AddUrlScheme("your_scheme") and webView.RemoveUrlScheme("your_scheme") + if (string.Equals(message.path, "webview")) + { + Vector3 direction = Vector3.zero; + + + if (message.args.ContainsKey("funcname")) + { + if (string.Equals(message.args["funcname"], "dnqueryuserinfo")) + { + if (message.args.ContainsKey("callback")) + { + + Debug.Log("Will callback"); + string callbackname = message.args["callback"]; + + Dictionary jsonData = new Dictionary(); + jsonData["appid"] = mAppId; + jsonData["openid"] = mOpenid; + jsonData["access_token"] = mToken; + jsonData["partition"] = mServerid; + jsonData["roleid"] = mRoleid; + jsonData["entertime"] = mOpenTime; + jsonData["nickname"] = mNickName; + string paramStr = MiniJSON.Json.Serialize(jsonData); + + //paramStr = "100539858"; + + string jsscript = string.Format("{0}({1})", callbackname, paramStr); + + Debug.Log(jsscript); + + webView.EvaluatingJavaScript(jsscript); + } + } + else if (string.Equals(message.args["funcname"], "dnclosewebview")) + { + CloseWebView(webView); + + } + else if (string.Equals(message.args["funcname"], "dniswifi")) + { + if (message.args.ContainsKey("callback")) + { + + Debug.Log("Will dniswifi callback"); + string callbackname = message.args["callback"]; + bool iswifi = (Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork); + int res = iswifi ? 1 : 0; + + string jsscript = string.Format("{0}({1})", callbackname, res); + + Debug.Log(jsscript); + + webView.EvaluatingJavaScript(jsscript); + } + } + else if (string.Equals(message.args["funcname"], "dnisbgopen")) + { + if (message.args.ContainsKey("callback")) + { + + Debug.Log("Will dnisbgopen callback"); + string callbackname = message.args["callback"]; + int res = _is_bgopen ? 1 : 0; + + string jsscript = string.Format("{0}({1})", callbackname, res); + + Debug.Log(jsscript); + + webView.EvaluatingJavaScript(jsscript); + } + } + else if (string.Equals(message.args["funcname"], "dnopenbg")) + { + _is_bgopen = true; + m_uiUtility.OnSetBg(true); + } + else if (string.Equals(message.args["funcname"], "dnclosebg")) + { + _is_bgopen = false; + m_uiUtility.OnSetBg(false); + } + else if (string.Equals(message.args["funcname"], "dnchangemenu")) + { + if (message.args.ContainsKey("menutype")) + { + // 0: main menu 1; detail + int menutype = int.Parse(message.args["menutype"]); + m_uiUtility.OnSetWebViewMenu(menutype); + } + } + else if (string.Equals(message.args["funcname"], "dnbackgame")) + { + if (message.args.ContainsKey("backtype")) + { + int backtype = int.Parse(message.args["backtype"]); + m_uiUtility.OnSetWebViewMenu(backtype); + } + + if (message.args.ContainsKey("callback")) + { + Debug.Log("Will dnbackgame callback"); + string callbackname = message.args["callback"]; + string jsscript = string.Format("{0}()", callbackname); + Debug.Log(jsscript); + + webView.EvaluatingJavaScript(jsscript); + } + } + else if (string.Equals(message.args["funcname"], "dnrefreshredpoint")) + { + if (message.args.ContainsKey("args")) + { + string redpointinfo = WWW.UnEscapeURL(message.args["args"]); + Debug.Log("dnrefreshredpoint" + redpointinfo); + m_uiUtility.OnWebViewRefershRefPoint(redpointinfo); + } + } + else if (string.Equals(message.args["funcname"], "dnsetheaderinfo")) + { + if (message.args.ContainsKey("args")) + { + string headerinfo = WWW.UnEscapeURL(message.args["args"]); + Debug.Log("dnsetheaderinfo" + headerinfo); + m_uiUtility.OnWebViewSetheaderInfo(headerinfo); + } + } + else if (string.Equals(message.args["funcname"], "dnshownav")) + { + if (message.args.ContainsKey("type")) + { + int show = int.Parse(message.args["type"]); + + if (show == 1) + _gap = GetGap(); + else + _gap = 0; + _webView.ForceResize(); + + } + } + else if (string.Equals(message.args["funcname"], "dncloseloading")) + { + if (message.args.ContainsKey("show")) + { + int show = int.Parse(message.args["show"]); + Debug.Log("dncloseloading: " + message.args["show"]); + + m_uiUtility.OnWebViewCloseLoading(show); + + if (show == 1) + _webView.Hide(); + else + _webView.Show(); + } + } + else if (string.Equals(message.args["funcname"], "dnshowreconnect")) + { + if (message.args.ContainsKey("show")) + { + int show = int.Parse(message.args["show"]); + Debug.Log("dnshowreconnect: " + message.args["show"]); + + m_uiUtility.OnWebViewShowReconnect(show); + + if (show == 1) + _webView.Hide(); + else + _webView.Show(); + } + } + else if (string.Equals(message.args["funcname"], "dnsetlivetab")) + { + m_uiUtility.OnWebViewLiveTab(); + } + else if (string.Equals(message.args["funcname"], "dnbackhistory")) + { + _webView.GoBack(); + } + else if (string.Equals(message.args["funcname"], "dnsetshareinfo")) + { + string info = WWW.UnEscapeURL(message.args["args"]); + //Debug.Log("dnsetshareinfo" + info); + Dictionary dic = MiniJSON.Json.Deserialize(info) as Dictionary; + XPlatform platf = gameObject.GetComponent(); + object title, imgUrl, desc, url, type; + dic.TryGetValue("title", out title); + dic.TryGetValue("imgurl", out imgUrl); + dic.TryGetValue("desc", out desc); + dic.TryGetValue("url", out url); + dic.TryGetValue("type", out type); + //Debug.Log("title: " + title + " url: " + url + " desc: " + desc + " img: " + imgUrl + " type: " + type); + if (type.Equals("qq") || type.Equals("qzone")) + { + Dictionary jsondata = new Dictionary(); + jsondata["scene"] = type.Equals("qq") ? "Session" : "QZone"; + if (url != null) jsondata["targetUrl"] = "https:"+url.ToString(); + if (imgUrl != null) jsondata["imageUrl"] = imgUrl.ToString(); + if (title != null) jsondata["title"] = title.ToString(); + if (desc != null) jsondata["description"] = desc.ToString(); + jsondata["summary"] = ""; + string json = MiniJSON.Json.Serialize(jsondata); + platf.SendGameExData("share_send_to_struct_qq", json); + } + else if (type.Equals("weixin") || type.Equals("timeline")) + { + if (!gameObject.activeSelf) return; + StartCoroutine(DownloadPic(imgUrl.ToString(), (filepath) => + { + //Debug.Log("cb: "+filepath); + if (!string.IsNullOrEmpty(filepath)) + { + Dictionary jsondata = new Dictionary(); + jsondata["scene"] = type.Equals("weixin") ? "Session" : "Timeline"; + if (title != null) jsondata["title"] = title.ToString(); + if (desc != null) jsondata["desc"] = desc.ToString(); + if (url != null) jsondata["url"] = url.ToString(); + jsondata["mediaTagName"] = "MSG_INVITE"; + jsondata["filePath"] = filepath; + jsondata["messageExt"] = "ShareUrlWithWeixin"; + string json = MiniJSON.Json.Serialize(jsondata); + platf.SendGameExData("share_send_to_with_url_wx", json); + } + })); + } + else + { + Debug.LogError("err type: " + type); + } + } + } + } + // else if (string.Equals(message.path, "close")) { + // //8. When you done your work with the webview, + // //you can hide it, destory it and do some clean work. + // webView.Hide(); + // Destroy(webView); + // webView.OnReceivedMessage -= OnReceivedMessage; + // webView.OnLoadComplete -= OnLoadComplete; + // webView.OnWebViewShouldClose -= OnWebViewShouldClose; + // webView.OnEvalJavaScriptFinished -= OnEvalJavaScriptFinished; + // webView.InsetsForScreenOreitation -= InsetsForScreenOreitation; + // _webView = null; + //} + } + + + IEnumerator DownloadPic(string path, Action cb) + { + int hash = Mathf.Abs( path.GetHashCode()); + string dir = Application.temporaryCachePath + "/ImageCache/"; + try + { + if (!Directory.Exists(dir)) Directory.CreateDirectory(dir); + } + catch { } + string pa = dir + hash; + if (File.Exists(pa)) + { + cb(pa); + } + else + { + string url = path; + //print(url+" pa: "+pa); + WWW w = new WWW(url); + while (!w.isDone) + yield return w; + if (!string.IsNullOrEmpty(w.error)) + { + Debug.LogError("error:"+w.error); + cb(string.Empty); + } + else + { + try + { + Texture2D image = w.texture; + byte[] pngData = image.EncodeToJPG(); + File.WriteAllBytes(pa, pngData); + cb(pa); + } + catch(Exception e) { cb(string.Empty); Debug.LogError("wraite error"+e.StackTrace); } + } + w.Dispose(); + w = null; + } + } + + //9. By using EvaluatingJavaScript method, you can talk to webview from Unity. + //It can evel a javascript or run a js method in the web page. + //(In the demo, it will be called when the cube hits the sphere) + public void ShowAlertInWebview(float time, bool first) { + _moveVector = Vector3.zero; + if (first) { + //Eval the js and wait for the OnEvalJavaScriptFinished event to be raised. + //The sample(float time) is written in the js in webpage, in which we pop + //up an alert and return a demo string. + //When the js excute finished, OnEvalJavaScriptFinished will be raised. + _webView.EvaluatingJavaScript("sample(" + time +")"); + } + } + + //In this demo, we set the text to the return value from js. + void OnEvalJavaScriptFinished(UniWebView webView, string result) { + Debug.Log("js result: " + result); + } + + //10. If the user close the webview by tap back button (Android) or toolbar Done button (iOS), + // we should set your reference to null to release it. + // Then we can return true here to tell the webview to dismiss. + bool OnWebViewShouldClose(UniWebView webView) { + if (webView == _webView) { + _webView = null; + return true; + } + return false; + } + + public void EvalJsScript(string jsscript) + { + Debug.Log(jsscript); + + if (jsscript.Contains("DNBackClick")) + { + if (_webView != null) + { + try + { + _webView.EvaluatingJavaScript(jsscript); + } + catch + { + CloseWebView(_webView); + } + } + } + else + { + if (_webView != null) + _webView.EvaluatingJavaScript(jsscript); + } + + } + + public void OnShowWebView(bool show) + { + if (_webView != null) + { + if (show) + _webView.Show(); + else + _webView.Hide(); + } + } + + private int GetGap() + { +#if UNITY_IOS + if (Screen.width == 1920) + return 35 * Screen.width / 1920 + (Screen.height - (Screen.width * 1080 / 1920))/4; + else + return (int)(35*1.3 * Screen.width / 1920) + (Screen.height - (Screen.width * 1080 / 1920))/4; +#else + return 90 * Screen.width / 1920 + (Screen.height - (Screen.width * 1080 / 1920))/2; +#endif + } + + // This method will be called when the screen orientation changed. Here we returned UniWebViewEdgeInsets(5,5,bottomInset,5) + // for both situation. Although they seem to be the same, screenHeight was changed, leading a difference between the result. + // eg. on iPhone 5, bottomInset is 284 (568 * 0.5) in portrait mode while it is 160 (320 * 0.5) in landscape. + UniWebViewEdgeInsets InsetsForScreenOreitation(UniWebView webView, UniWebViewOrientation orientation) { + //int bottomInset = (int)(UniWebViewHelper.screenHeight * 0.5f); + //int bottomInset = (int)(UniWebViewHelper.screenHeight); + //int rightInset = (int)(UniWebViewHelper.screenWidth); + + Debug.Log("Gap: " + _gap.ToString()); + + return new UniWebViewEdgeInsets(_gap, 0, 0, 0); + } +#endif //End of #if UNITY_IOS || UNITY_ANDROID + + +#endif +} diff --git a/Client/Assets/Scripts/UniWebView/UniWeb.cs.meta b/Client/Assets/Scripts/UniWebView/UniWeb.cs.meta new file mode 100644 index 00000000..d1dfccef --- /dev/null +++ b/Client/Assets/Scripts/UniWebView/UniWeb.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: ebd9bd53848baa043b6786b123a58ddb +timeCreated: 1497252612 +licenseType: Pro +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: -- cgit v1.1-26-g67d0