DeMaTianJi/Assets/Vuplex/WebView/Scripts/Common/CanvasWebViewPrefab.cs

/**
* Copyright (c) 2021 Vuplex Inc. All rights reserved.
*
* Licensed under the Vuplex Commercial Software Library License, you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at
*
*     https://vuplex.com/commercial-library-license
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using UnityEngine;
using Vuplex.WebView.Internal;

namespace Vuplex.WebView {

    /// <summary>
    /// CanvasWebViewPrefab is a prefab that makes it easy to view and interact with an IWebView in a 2D Canvas.
    /// It takes care of creating an IWebView, displaying its texture, and handling pointer interactions
    /// from the user, like clicking, dragging, and scrolling. So, all you need to do is specify a URL or HTML to load,
    /// and then the user can view and interact with it. For use outside of a Canvas, see WebViewPrefab instead.
    /// </summary>
    /// <remarks>
    /// There are two ways to create a CanvasWebViewPrefab:
    /// <list type="number">
    ///   <item>
    ///     By dragging the CanvasWebViewPrefab.prefab file into your scene via the editor and setting its "Initial URL" property.</item>
    ///   <item>
    ///     Or by creating an instance programmatically with CanvasWebViewPrefab.Instantiate(), waiting for
    ///     it to initialize, and then calling methods on its WebView property, like LoadUrl().
    ///   </item>
    /// </list>
    /// <para>
    /// If your use case requires a high degree of customization, you can instead create an IWebView
    /// outside of the prefab with Web.CreateWebView().
    /// </para>
    /// See also:
    /// <list type="bullet">
    ///   <item>WebViewPrefab: https://developer.vuplex.com/webview/WebViewPrefab</item>
    ///   <item>How clicking and scrolling works: https://support.vuplex.com/articles/clicking</item>
    ///   <item>IWebView: https://developer.vuplex.com/webview/IWebView</item>
    ///   <item>Web (static methods): https://developer.vuplex.com/webview/Web</item>
    /// </list>
    /// </remarks>
    [HelpURL("https://developer.vuplex.com/webview/CanvasWebViewPrefab")]
    public partial class CanvasWebViewPrefab : BaseWebViewPrefab {

        public override event EventHandler<ClickedEventArgs> Clicked {
            add {
                if (_native2DModeActive) {
                    _logNative2DModeWarning("The CanvasWebViewPrefab.Clicked event is not supported in Native 2D Mode.");
                }
                base.Clicked += value;
            }
            remove {
                base.Clicked -= value;
            }
        }

        public override event EventHandler<ScrolledEventArgs> Scrolled {
            add {
                if (_native2DModeActive) {
                    _logNative2DModeWarning("The CanvasWebViewPrefab.Scrolled event is not supported in Native 2D Mode.");
                }
                base.Scrolled += value;
            }
            remove {
                base.Scrolled -= value;
            }
        }

        /// <summary>
        /// Enables or disables Native 2D Mode, which makes it so that 3D WebView positions a native 2D webview in front of the Unity game view
        /// instead of displaying web content as a texture in the Unity scene. If the 3D WebView package
        /// in use doesn't support Native 2D Mode, then the default rendering mode is used instead.
        /// For more info on Native 2D Mode, please see [this article](https://support.vuplex.com/articles/native-2d-mode).
        /// </summary>
        /// <remarks>
        /// Important notes:
        /// <list type="bullet">
        ///   <item>
        ///     Native 2D Mode is only supported for 3D WebView for Android (non-Gecko) and 3D WebView for iOS.
        ///     For other packages, the default render mode is used instead.
        ///   </item>
        ///   <item>Native 2D Mode requires that the canvas's render mode be set to "Screen Space - Overlay".</item>
        /// </list>
        /// </remarks>
        [Label("Native 2D Mode (Android, iOS, WebGL, and UWP only)")]
        [Tooltip("Native 2D Mode positions a native 2D webview in front of the Unity game view instead of rendering web content as a texture in the Unity scene. Native 2D Mode provides better performance on iOS and UWP, because the default mode of rendering web content to a texture is slower. \n\nImportant notes:\n• Native 2D Mode is only supported for Android (non-Gecko), iOS, WebGL, and UWP. For the other 3D WebView packages, the default render mode is used instead.\n• Native 2D Mode requires that the canvas's render mode be set to \"Screen Space - Overlay\".")]
        [HideInInspector]
        [Header("Platform-specific")]
        public bool Native2DModeEnabled;

        /// <summary>
        /// Determines whether the operating system's native on-screen keyboard is
        /// automatically shown when a text input in the webview is focused. The default for
        /// CanvasWebViewPrefab is `true`.
        /// </summary>
        /// <remarks>
        /// The native on-screen keyboard is only supported for the following packages:
        /// <list type="bullet">
        ///   <item>3D WebView for Android (non-Gecko)</item>
        ///   <item>3D WebView for iOS</item>
        /// </list>
        /// </remarks>
        [Label("Native On-Screen Keyboard (Android and iOS only)")]
        [Tooltip("Determines whether the operating system's native on-screen keyboard is automatically shown when a text input in the webview is focused. The native on-screen keyboard is only supported for the following packages:\n• 3D WebView for Android (non-Gecko)\n• 3D WebView for iOS")]
        public bool NativeOnScreenKeyboardEnabled = true;

        /// <summary>
        /// Sets the webview's initial resolution in pixels per Unity unit.
        /// You can change the resolution to make web content appear larger or smaller.
        /// For more information on scaling web content, see
        /// [this support article](https://support.vuplex.com/articles/how-to-scale-web-content).
        /// </summary>
        /// <remarks>
        /// This property is ignored when running in [Native 2D Mode](https://support.vuplex.com/articles/native-2d-mode).
        /// </remarks>
        [Label("Initial Resolution (px / Unity unit)")]
        [Tooltip("You can change this to make web content appear larger or smaller. Note that This property is ignored when running in Native 2D Mode.")]
        [HideInInspector]
        public float InitialResolution = 1;

        /// <summary>
        /// Determines the scroll sensitivity. The default sensitivity for CanvasWebViewPrefab is `15`.
        /// </summary>
        /// <remarks>
        /// This property is ignored when running in [Native 2D Mode](https://support.vuplex.com/articles/native-2d-mode).
        /// </remarks>
        [HideInInspector]
        [Tooltip("Determines the scroll sensitivity. Note that This property is ignored when running in Native 2D Mode.")]
        public float ScrollingSensitivity = 15;

        public override bool Visible {
            get {
                var native2DWebView = _getNative2DWebViewIfActive();
                if (native2DWebView != null) {
                    return native2DWebView.Visible;
                }
                return base.Visible;
            }
            set {
                var native2DWebView = _getNative2DWebViewIfActive();
                if (native2DWebView != null) {
                    native2DWebView.SetVisible(value);
                    return;
                }
                base.Visible = value;
            }
        }

        /// <summary>
        /// Creates a new instance.
        /// </summary>
        /// <remarks>
        /// The WebView property is available after initialization completes,
        /// which is indicated by WaitUntilInitialized().
        /// </remarks>
        /// <example>
        /// <code>
        /// // Create a CanvasWebViewPrefab
        /// var canvasWebViewPrefab = CanvasWebViewPrefab.Instantiate();
        /// // Position the prefab how we want it
        /// var canvas = GameObject.Find("Canvas");
        /// canvasWebViewPrefab.transform.parent = canvas.transform;
        /// var rectTransform = canvasWebViewPrefab.transform as RectTransform;
        /// rectTransform.anchoredPosition3D = Vector3.zero;
        /// rectTransform.offsetMin = Vector2.zero;
        /// rectTransform.offsetMax = Vector2.zero;
        /// canvasWebViewPrefab.transform.localScale = Vector3.one;
        /// // Load a URL once the prefab finishes initializing
        /// await canvasWebViewPrefab.WaitUntilInitialized();
        /// canvasWebViewPrefab.WebView.LoadUrl("https://vuplex.com");
        /// </code>
        /// </example>
        public static CanvasWebViewPrefab Instantiate() {

            return Instantiate(new WebViewOptions());
        }

        /// <summary>
        /// Like Instantiate(), except it also accepts an object
        /// of options flags that can be used to alter the generated webview's behavior.
        /// </summary>
        public static CanvasWebViewPrefab Instantiate(WebViewOptions options) {

            var prefabPrototype = (GameObject) Resources.Load("CanvasWebViewPrefab");
            var gameObject = (GameObject) Instantiate(prefabPrototype);
            var canvasWebViewPrefab = gameObject.GetComponent<CanvasWebViewPrefab>();
            canvasWebViewPrefab._options = options;
            return canvasWebViewPrefab;
        }

        /// <summary>
        /// Like `Instantiate()`, except it initializes the instance with an existing, initialized
        /// `IWebView` instance. This causes the `CanvasWebViewPrefab` to use the existing
        /// `IWebView` instance instead of creating a new one.
        /// </summary>
        public static CanvasWebViewPrefab Instantiate(IWebView webView) {

            var prefabPrototype = (GameObject) Resources.Load("CanvasWebViewPrefab");
            var gameObject = (GameObject) Instantiate(prefabPrototype);
            var canvasWebViewPrefab = gameObject.GetComponent<CanvasWebViewPrefab>();
            canvasWebViewPrefab.SetWebViewForInitialization(webView);
            return canvasWebViewPrefab;
        }

        [Obsolete("CanvasWebViewPrefab.Init() has been removed. The CanvasWebViewPrefab script now initializes itself automatically, so Init() no longer needs to be called.", true)]
        public void Init() {}

        [Obsolete("CanvasWebViewPrefab.Init() has been removed. The CanvasWebViewPrefab script now initializes itself automatically, so Init() no longer needs to be called.", true)]
        public void Init(WebViewOptions options) {}

        [Obsolete("CanvasWebViewPrefab.Init() has been removed. The CanvasWebViewPrefab script now initializes itself automatically, so Init() no longer needs to be called. Please use CanvasWebViewPrefab.SetWebViewForInitialization(IWebView) instead.", true)]
        public void Init(IWebView webView) {}

        RectTransform _cachedRectTransform;
        Canvas _canvas {
            get {
                if (_canvasGetter == null) {
                    _canvasGetter = new CachingGetter<Canvas>(GetComponentInParent<Canvas>, 1, this);
                }
                return _canvasGetter.GetValue();
            }
        }
        CachingGetter<Canvas> _canvasGetter;
        bool _native2DModeActive {
            get {
                var webViewWith2DMode = WebView as IWithNative2DMode;
                return webViewWith2DMode != null && webViewWith2DMode.Native2DModeEnabled;
            }
        }
        RectTransform _rectTransform {
            get {
                if (_cachedRectTransform == null) {
                    _cachedRectTransform = GetComponent<RectTransform>();
                }
                return _cachedRectTransform;
            }
        }
        bool _setCustomPointerInputDetector;

        // Partial method implemented by various 3D WebView packages
        // to provide platform-specific warnings.
        partial void OnInit();

        bool _canNative2DModeBeEnabled(bool logWarnings = false) {

            if (_canvas?.renderMode == RenderMode.WorldSpace) {
                if (logWarnings) {
                    _logNative2DModeWarning("CanvasWebViewPrefab.Native2DModeEnabled is enabled but the canvas's render mode is set to World Space, so Native 2D Mode will not be enabled. In order to use Native 2D Mode, please switch the canvas's render mode to \"Screen Space - Overlay\" or \"Screen Space - Camera\".");
                }
                return false;
            }
            if (XRUtils.XRSettings.enabled) {
                if (logWarnings) {
                    _logNative2DModeWarning("CanvasWebViewPrefab.Native2DModeEnabled is enabled but XR is enabled, so Native 2D Mode will not be enabled.");
                }
                return false;
            }
            return true;
        }

        protected override Vector2 _convertRatioPointToUnityUnits(Vector2 point) {

            // Use Vector2.Scale() because Vector2 * Vector2 isn't supported in Unity 2017.
            return Vector2.Scale(point, _rectTransform.rect.size);
        }

        protected override float _getInitialResolution() {

            return InitialResolution;
        }

        IWithNative2DMode _getNative2DWebViewIfActive() {

            var webViewWith2DMode = WebView as IWithNative2DMode;
            if (webViewWith2DMode != null && webViewWith2DMode.Native2DModeEnabled) {
                return webViewWith2DMode;
            }
            return null;
        }

        protected override bool _getNativeOnScreenKeyboardEnabled() {

            return NativeOnScreenKeyboardEnabled;
        }

        protected override float _getScrollingSensitivity() {

            return ScrollingSensitivity;
        }

        Rect _getScreenSpaceRect() {

            var canvas = _canvas;
            if (canvas == null) {
                WebViewLogger.LogError("Unable to determine the screen space rect for Native 2D Mode because the CanvasWebViewPrefab is not placed in a Canvas. Please place the CanvasWebViewPrefab as the child of a Unity UI Canvas.");
                return Rect.zero;
            }
            var worldCorners = new Vector3[4];
            _rectTransform.GetWorldCorners(worldCorners);
            var topLeftCorner = worldCorners[1];
            var bottomRightCorner = worldCorners[3];

            if (canvas.renderMode != RenderMode.ScreenSpaceOverlay) {
                var camera = canvas.worldCamera;
                if (camera == null) {
                    WebViewLogger.LogError("Unable to determine the screen space rect for Native 2D Mode because the Canvas's render camera is not set. Please set the Canvas's \"Render Camera\" setting or change its render mode to \"Screen Space - Overlay\".");
                } else {
                    topLeftCorner = camera.WorldToScreenPoint(topLeftCorner);
                    bottomRightCorner = camera.WorldToScreenPoint(bottomRightCorner);
                }
            }
            var x = topLeftCorner.x;
            var y = Screen.height - topLeftCorner.y;
            var width = bottomRightCorner.x - topLeftCorner.x;
            var height = topLeftCorner.y - bottomRightCorner.y;
            return new Rect(x, y, width, height);
        }

        Rect? _getScreenSpaceRectIfNative2DModeIsEnabled() {

            if (!Native2DModeEnabled) {
                return null;
            }
            if (_canNative2DModeBeEnabled(true)) {
                return _getScreenSpaceRect();
            }
            return null;
        }

        protected override ViewportMaterialView _getVideoLayer() {

            return transform.Find("VideoLayer").GetComponent<ViewportMaterialView>();
        }

        protected override ViewportMaterialView _getView() {

            return transform.Find("CanvasWebViewPrefabView").GetComponent<ViewportMaterialView>();
        }

        void _initCanvasPrefab() {

            OnInit();
            Initialized += _logNative2DRecommendationIfNeeded;
            _init(_rectTransform.rect.size, _getScreenSpaceRectIfNative2DModeIsEnabled());
        }

        void _logNative2DModeWarning(string message) {

            WebViewLogger.LogWarning(message + " For more info, please see this article: <em>https://support.vuplex.com/articles/native-2d-mode</em>");
        }

        void _logNative2DRecommendationIfNeeded(object sender, EventArgs eventArgs) {

            var webViewWith2DMode = WebView as IWithNative2DMode;
            if (_canNative2DModeBeEnabled() && webViewWith2DMode != null && !webViewWith2DMode.Native2DModeEnabled) {
                WebViewLogger.LogTip("This platform supports Native 2D Mode, so consider enabling CanvasWebViewPrefab.Native2DModeEnabled for best results. For more info, see https://support.vuplex.com/articles/native-2d-mode .");
            }
        }

        void OnDisable() {
            // 强制横屏并禁止自动旋转
            // When in Native 2D Mode, hide the webview when the CanvasWebViewPrefab is deactivated.
            var native2DWebView = _getNative2DWebViewIfActive();
            if (native2DWebView != null) {
                native2DWebView.SetVisible(false);
            }
        }

        void OnEnable() {
        // 强制横屏并禁止自动旋转
            // When in Native 2D Mode, show the webview when the CanvasWebViewPrefab is activated.
            var native2DWebView = _getNative2DWebViewIfActive();
            if (native2DWebView != null) {
                native2DWebView.SetVisible(true);
            }
        }

        protected override void _setVideoLayerPosition(Rect videoRect) {

            var videoRectTransform = _videoLayer.transform as RectTransform;
            // Use Vector2.Scale() because Vector2 * Vector2 isn't supported in Unity 2017.
            videoRectTransform.anchoredPosition = Vector2.Scale(Vector2.Scale(videoRect.position, _rectTransform.rect.size), new Vector2(1, -1));
            videoRectTransform.sizeDelta = Vector2.Scale(videoRect.size, _rectTransform.rect.size);
        }

        void Start() {

            _initCanvasPrefab();
        }

        void Update() {

            if (WebView == null) {
                return;
            }
            // Handle updating the rect for a native 2D webview.
            var native2DWebView = _getNative2DWebViewIfActive();
            if (native2DWebView != null) {
                var screenSpaceRect = _getScreenSpaceRect();
                if (native2DWebView.Rect != screenSpaceRect) {
                    native2DWebView.SetRect(screenSpaceRect);
                }
                return;
            }
            // Handle resizing a regular webview.
            var rect = _rectTransform.rect;
            if (WebView.Size != rect.size) {
                WebView.Resize(rect.width, rect.height);
            }
        }
    }
}