@javascriptcommon/react-native-webview 13.12.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# React Native WebView
+
+![star this repo](https://img.shields.io/github/stars/react-native-webview/react-native-webview?style=flat-square)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+[![NPM Version](https://img.shields.io/npm/v/react-native-webview.svg?style=flat-square)](https://www.npmjs.com/package/react-native-webview)
+![Npm Downloads](https://img.shields.io/npm/dm/react-native-webview.svg)
+
+**React Native WebView** is a community-maintained WebView component for React Native. It is intended to be a replacement for the built-in WebView (which was [removed from core](https://github.com/react-native-community/discussions-and-proposals/pull/3)).
+
+### Maintainers
+
+**Many thanks to these companies** for providing us with time to work on open source.  
+Please note that maintainers spend a lot of free time working on this too so feel free to sponsor them, **it really makes a difference.**
+
+- [Thibault Malbranche](https://github.com/Titozzz) ([Twitter @titozzz](https://twitter.com/titozzz)) from [Brigad](https://www.brigad.co/en-gb/about-us)  
+[*Sponsor me* ❤️ !](https://github.com/sponsors/Titozzz)
+
+
+Windows and macOS are managed by Microsoft, notably:
+- [Alexander Sklar](https://github.com/asklar) ([Twitter @alexsklar](https://twitter.com/alexsklar)) from [React Native for Windows](https://microsoft.github.io/react-native-windows/)
+- [Chiara Mooney](https://github.com/chiaramooney) from [React Native for Windows @ Microsoft](https://microsoft.github.io/react-native-windows/)
+
+Shout-out to [Jamon Holmgren](https://github.com/jamonholmgren) from [Infinite Red](https://infinite.red) for helping a lot with the repo when he had more available time.
+
+### Disclaimer
+
+Maintaining WebView is very complex because it is often used for many different use cases (rendering SVGs, PDFs, login flows, and much more). We also support many platforms and both architectures of react-native.
+
+Since WebView was extracted from the React Native core, nearly 500 pull requests have been merged.  
+Considering that we have limited time, issues will mostly serve as a discussion place for the community, while **we will prioritize reviewing and merging pull requests.** 
+
+### Platform compatibility
+
+This project is compatible with **iOS**,  **Android**, **Windows** and **macOS**.  
+This project supports both **the old** (paper) **and the new architecture** (fabric).  
+This project is compatible with [expo](https://docs.expo.dev/versions/latest/sdk/webview/).
+
+### Getting Started
+
+Read our [Getting Started Guide](docs/Getting-Started.md). If any step seems unclear, please create a pull request.
+
+### Versioning
+
+This project follows [semantic versioning](https://semver.org/). We do not hesitate to release breaking changes but they will be in a major version.
+
+### Usage
+
+Import the `WebView` component from `react-native-webview` and use it like so:
+
+```tsx
+import React, { Component } from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+import { WebView } from 'react-native-webview';
+
+// ...
+const MyWebComponent = () => {
+  return <WebView source={{ uri: 'https://reactnative.dev/' }} style={{ flex: 1 }} />;
+}
+```
+
+For more, read the [API Reference](./docs/Reference.md) and [Guide](./docs/Guide.md). If you're interested in contributing, check out the [Contributing Guide](./docs/Contributing.md).
+
+### Common issues
+
+- If you're getting `Invariant Violation: Native component for "RNCWebView does not exist"` it likely means you forgot to run `react-native link` or there was some error with the linking process
+- If you encounter a build error during the task `:app:mergeDexRelease`, you need to enable multidex support in `android/app/build.gradle` as discussed in [this issue](https://github.com/react-native-webview/react-native-webview/issues/1344#issuecomment-650544648)
+
+#### Contributing
+
+Contributions are welcome, see [Contributing.md](https://github.com/react-native-webview/react-native-webview/blob/master/docs/Contributing.md)
+
+### License
+
+MIT
+
+### Translations
+
+This readme is available in:
+
+- [Brazilian portuguese](docs/README.portuguese.md)
+- [French](docs/README.french.md)
+- [Italian](docs/README.italian.md)

package/android/build.gradle

@@ -0,0 +1,110 @@
+import java.nio.file.Paths
+
+buildscript {
+    ext.safeExtGet = {prop ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : project.properties['ReactNativeWebView_' + prop]
+    }
+    repositories {
+        google()
+        gradlePluginPortal()
+    }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion')}")
+        classpath("com.android.tools.build:gradle:7.0.4")
+    }
+}
+
+def getExtOrIntegerDefault(prop) {
+  return rootProject.ext.has(prop) ? rootProject.ext.get(prop) : (project.properties['ReactNativeWebView_' + prop]).toInteger()
+}
+
+static def findNodeModulePath(baseDir, packageName) {
+    def basePath = baseDir.toPath().normalize()
+    // Node's module resolution algorithm searches up to the root directory,
+    // after which the base path will be null
+    while (basePath) {
+        def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
+        if (candidatePath.toFile().exists()) {
+            return candidatePath.toString()
+        }
+        basePath = basePath.getParent()
+    }
+    return null
+}
+
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  if (major == 7 && minor >= 3) {
+    return true
+  }
+
+  return major >= 8
+}
+
+apply plugin: 'com.android.library'
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+apply plugin: 'kotlin-android'
+
+android {
+    if (supportsNamespace()) {
+        namespace "com.reactnativecommunity.webview"
+        buildFeatures {
+            buildConfig true
+        }
+
+        sourceSets {
+            main {
+                manifest.srcFile "src/main/AndroidManifestNew.xml"
+            }
+        }
+    }
+
+    compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+
+    defaultConfig {
+        minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+        targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    }
+
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch']
+            } else {
+                java.srcDirs += ['src/oldarch']
+            }
+        }
+    }
+}
+
+def reactNativePath = findNodeModulePath(projectDir, "react-native")
+def codegenPath = findNodeModulePath(projectDir, "@react-native/codegen")
+if (codegenPath == null) {
+  // Compat for 0.71 and lower (to be removed)
+  codegenPath = findNodeModulePath(projectDir, "react-native-codegen")
+}
+
+repositories {
+    maven {
+        url "${reactNativePath}/android"
+    }
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion')}"
+    implementation "androidx.webkit:webkit:${safeExtGet('webkitVersion')}"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+ReactNativeWebView_kotlinVersion=1.6.0
+ReactNativeWebView_webkitVersion=1.4.0
+ReactNativeWebView_compileSdkVersion=31
+ReactNativeWebView_targetSdkVersion=31
+ReactNativeWebView_minSdkVersion=21

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,15 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.reactnativecommunity.webview">
+
+  <application>
+    <provider
+      android:name=".RNCWebViewFileProvider"
+      android:authorities="${applicationId}.fileprovider"
+      android:exported="false"
+      android:grantUriPermissions="true">
+      <meta-data
+        android:name="android.support.FILE_PROVIDER_PATHS"
+        android:resource="@xml/file_provider_paths" />
+    </provider>
+  </application>
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <application>
+    <provider
+      android:name=".RNCWebViewFileProvider"
+      android:authorities="${applicationId}.fileprovider"
+      android:exported="false"
+      android:grantUriPermissions="true">
+      <meta-data
+        android:name="android.support.FILE_PROVIDER_PATHS"
+        android:resource="@xml/file_provider_paths" />
+    </provider>
+  </application>
+</manifest>

package/android/src/main/java/com/reactnativecommunity/webview/RNCBasicAuthCredential.java

@@ -0,0 +1,11 @@
+package com.reactnativecommunity.webview;
+
+class RNCBasicAuthCredential {
+    String username;
+    String password;
+
+    RNCBasicAuthCredential(String username, String password) {
+        this.username = username;
+        this.password = password;
+    }
+}

package/android/src/main/java/com/reactnativecommunity/webview/RNCWebChromeClient.java

@@ -0,0 +1,372 @@
+package com.reactnativecommunity.webview;
+
+import android.Manifest;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Message;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.webkit.ConsoleMessage;
+import android.webkit.GeolocationPermissions;
+import android.webkit.PermissionRequest;
+import android.webkit.ValueCallback;
+import android.webkit.WebChromeClient;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.FrameLayout;
+
+import androidx.annotation.RequiresApi;
+import androidx.core.content.ContextCompat;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.build.ReactBuildConfig;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.reactnativecommunity.webview.events.TopLoadingProgressEvent;
+import com.reactnativecommunity.webview.events.TopOpenWindowEvent;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class RNCWebChromeClient extends WebChromeClient implements LifecycleEventListener {
+    protected static final FrameLayout.LayoutParams FULLSCREEN_LAYOUT_PARAMS = new FrameLayout.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER);
+
+    protected static final int FULLSCREEN_SYSTEM_UI_VISIBILITY = View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
+            View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
+            View.SYSTEM_UI_FLAG_LAYOUT_STABLE |
+            View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
+            View.SYSTEM_UI_FLAG_FULLSCREEN |
+            View.SYSTEM_UI_FLAG_IMMERSIVE |
+            View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
+
+    protected static final int COMMON_PERMISSION_REQUEST = 3;
+
+    protected RNCWebView mWebView;
+
+    protected View mVideoView;
+    protected WebChromeClient.CustomViewCallback mCustomViewCallback;
+
+    /*
+     * - Permissions -
+     * As native permissions are asynchronously handled by the PermissionListener, many fields have
+     * to be stored to send permissions results to the webview
+     */
+
+    // Webview camera & audio permission callback
+    protected PermissionRequest permissionRequest;
+    // Webview camera & audio permission already granted
+    protected List<String> grantedPermissions;
+
+    // Webview geolocation permission callback
+    protected GeolocationPermissions.Callback geolocationPermissionCallback;
+    // Webview geolocation permission origin callback
+    protected String geolocationPermissionOrigin;
+
+    // true if native permissions dialog is shown, false otherwise
+    protected boolean permissionsRequestShown = false;
+    // Pending Android permissions for the next request
+    protected List<String> pendingPermissions = new ArrayList<>();
+
+    protected RNCWebView.ProgressChangedFilter progressChangedFilter = null;
+    protected boolean mAllowsProtectedMedia = false;
+
+    protected boolean mHasOnOpenWindowEvent = false;
+
+    public RNCWebChromeClient(RNCWebView webView) {
+        this.mWebView = webView;
+    }
+
+    @Override
+    public boolean onCreateWindow(WebView view, boolean isDialog, boolean isUserGesture, Message resultMsg) {
+
+        final WebView newWebView = new WebView(view.getContext());
+
+        if(mHasOnOpenWindowEvent) {
+            newWebView.setWebViewClient(new WebViewClient(){
+            @Override
+            public boolean shouldOverrideUrlLoading (WebView subview, String url) {
+                WritableMap event = Arguments.createMap();
+                event.putString("targetUrl", url);
+
+                ((RNCWebView) view).dispatchEvent(
+                    view,
+                    new TopOpenWindowEvent(RNCWebViewWrapper.getReactTagFromWebView(view), event)
+                );
+
+                return true;
+            }
+            });
+        }
+
+        final WebView.WebViewTransport transport = (WebView.WebViewTransport) resultMsg.obj;
+        transport.setWebView(newWebView);
+        resultMsg.sendToTarget();
+
+        return true;
+    }
+
+    @Override
+    public boolean onConsoleMessage(ConsoleMessage message) {
+        if (ReactBuildConfig.DEBUG) {
+            return super.onConsoleMessage(message);
+        }
+        // Ignore console logs in non debug builds.
+        return true;
+    }
+
+    @Override
+    public void onProgressChanged(WebView webView, int newProgress) {
+        super.onProgressChanged(webView, newProgress);
+        final String url = webView.getUrl();
+        if (progressChangedFilter.isWaitingForCommandLoadUrl()) {
+            return;
+        }
+        int reactTag = RNCWebViewWrapper.getReactTagFromWebView(webView);
+        WritableMap event = Arguments.createMap();
+        event.putDouble("target", reactTag);
+        event.putString("title", webView.getTitle());
+        event.putString("url", url);
+        event.putBoolean("canGoBack", webView.canGoBack());
+        event.putBoolean("canGoForward", webView.canGoForward());
+        event.putDouble("progress", (float) newProgress / 100);
+
+        UIManagerHelper.getEventDispatcherForReactTag(this.mWebView.getThemedReactContext(), reactTag).dispatchEvent(new TopLoadingProgressEvent(reactTag, event));
+    }
+
+    @Override
+    public void onPermissionRequest(final PermissionRequest request) {
+
+        grantedPermissions = new ArrayList<>();
+
+        ArrayList<String> requestedAndroidPermissions = new ArrayList<>();
+        for (String requestedResource : request.getResources()) {
+            String androidPermission = null;
+
+            if (requestedResource.equals(PermissionRequest.RESOURCE_AUDIO_CAPTURE)) {
+                androidPermission = Manifest.permission.RECORD_AUDIO;
+            } else if (requestedResource.equals(PermissionRequest.RESOURCE_VIDEO_CAPTURE)) {
+                androidPermission = Manifest.permission.CAMERA;
+            } else if(requestedResource.equals(PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID)) {
+                if (mAllowsProtectedMedia) {
+                  grantedPermissions.add(requestedResource);
+                } else {
+                  /**
+                   * Legacy handling (Kept in case it was working under some conditions (given Android version or something))
+                   *
+                   * Try to ask user to grant permission using Activity.requestPermissions
+                   *
+                   * Find more details here: https://github.com/react-native-webview/react-native-webview/pull/2732
+                   */
+                  androidPermission = PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID;
+                }            }
+            // TODO: RESOURCE_MIDI_SYSEX, RESOURCE_PROTECTED_MEDIA_ID.
+            if (androidPermission != null) {
+                if (ContextCompat.checkSelfPermission(this.mWebView.getThemedReactContext(), androidPermission) == PackageManager.PERMISSION_GRANTED) {
+                    grantedPermissions.add(requestedResource);
+                } else {
+                    requestedAndroidPermissions.add(androidPermission);
+                }
+            }
+        }
+
+        // If all the permissions are already granted, send the response to the WebView synchronously
+        if (requestedAndroidPermissions.isEmpty()) {
+            request.grant(grantedPermissions.toArray(new String[0]));
+            grantedPermissions = null;
+            return;
+        }
+
+        // Otherwise, ask to Android System for native permissions asynchronously
+
+        this.permissionRequest = request;
+
+        requestPermissions(requestedAndroidPermissions);
+    }
+
+
+    @Override
+    public void onGeolocationPermissionsShowPrompt(String origin, GeolocationPermissions.Callback callback) {
+
+        if (ContextCompat.checkSelfPermission(this.mWebView.getThemedReactContext(), Manifest.permission.ACCESS_FINE_LOCATION)
+                != PackageManager.PERMISSION_GRANTED) {
+
+            /*
+             * Keep the trace of callback and origin for the async permission request
+             */
+            geolocationPermissionCallback = callback;
+            geolocationPermissionOrigin = origin;
+
+            requestPermissions(Collections.singletonList(Manifest.permission.ACCESS_FINE_LOCATION));
+
+        } else {
+            callback.invoke(origin, true, false);
+        }
+    }
+
+    private PermissionAwareActivity getPermissionAwareActivity() {
+        Activity activity = this.mWebView.getThemedReactContext().getCurrentActivity();
+        if (activity == null) {
+            throw new IllegalStateException("Tried to use permissions API while not attached to an Activity.");
+        } else if (!(activity instanceof PermissionAwareActivity)) {
+            throw new IllegalStateException("Tried to use permissions API but the host Activity doesn't implement PermissionAwareActivity.");
+        }
+        return (PermissionAwareActivity) activity;
+    }
+
+    private synchronized void requestPermissions(List<String> permissions) {
+
+        /*
+         * If permissions request dialog is displayed on the screen and another request is sent to the
+         * activity, the last permission asked is skipped. As a work-around, we use pendingPermissions
+         * to store next required permissions.
+         */
+
+        if (permissionsRequestShown) {
+            pendingPermissions.addAll(permissions);
+            return;
+        }
+
+        PermissionAwareActivity activity = getPermissionAwareActivity();
+        permissionsRequestShown = true;
+
+        activity.requestPermissions(
+                permissions.toArray(new String[0]),
+                COMMON_PERMISSION_REQUEST,
+                webviewPermissionsListener
+        );
+
+        // Pending permissions have been sent, the list can be cleared
+        pendingPermissions.clear();
+    }
+
+
+    private PermissionListener webviewPermissionsListener = (requestCode, permissions, grantResults) -> {
+
+        permissionsRequestShown = false;
+
+        /*
+         * As a "pending requests" approach is used, requestCode cannot help to define if the request
+         * came from geolocation or camera/audio. This is why shouldAnswerToPermissionRequest is used
+         */
+        boolean shouldAnswerToPermissionRequest = false;
+
+        for (int i = 0; i < permissions.length; i++) {
+
+            String permission = permissions[i];
+            boolean granted = grantResults[i] == PackageManager.PERMISSION_GRANTED;
+
+            if (permission.equals(Manifest.permission.ACCESS_FINE_LOCATION)
+                    && geolocationPermissionCallback != null
+                    && geolocationPermissionOrigin != null) {
+
+                if (granted) {
+                    geolocationPermissionCallback.invoke(geolocationPermissionOrigin, true, false);
+                } else {
+                    geolocationPermissionCallback.invoke(geolocationPermissionOrigin, false, false);
+                }
+
+                geolocationPermissionCallback = null;
+                geolocationPermissionOrigin = null;
+            }
+
+            if (permission.equals(Manifest.permission.RECORD_AUDIO)) {
+                if (granted && grantedPermissions != null) {
+                    grantedPermissions.add(PermissionRequest.RESOURCE_AUDIO_CAPTURE);
+                }
+                shouldAnswerToPermissionRequest = true;
+            }
+
+            if (permission.equals(Manifest.permission.CAMERA)) {
+                if (granted && grantedPermissions != null) {
+                    grantedPermissions.add(PermissionRequest.RESOURCE_VIDEO_CAPTURE);
+                }
+                shouldAnswerToPermissionRequest = true;
+            }
+
+            if (permission.equals(PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID)) {
+                if (granted && grantedPermissions != null) {
+                    grantedPermissions.add(PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID);
+                }
+                shouldAnswerToPermissionRequest = true;
+            }
+        }
+
+        if (shouldAnswerToPermissionRequest
+                && permissionRequest != null
+                && grantedPermissions != null) {
+            permissionRequest.grant(grantedPermissions.toArray(new String[0]));
+            permissionRequest = null;
+            grantedPermissions = null;
+        }
+
+        if (!pendingPermissions.isEmpty()) {
+            requestPermissions(pendingPermissions);
+            return false;
+        }
+
+        return true;
+    };
+
+    protected void openFileChooser(ValueCallback<Uri> filePathCallback, String acceptType) {
+      this.mWebView.getThemedReactContext().getNativeModule(RNCWebViewModule.class).startPhotoPickerIntent(filePathCallback, acceptType);
+    }
+
+    protected void openFileChooser(ValueCallback<Uri> filePathCallback) {
+      this.mWebView.getThemedReactContext().getNativeModule(RNCWebViewModule.class).startPhotoPickerIntent(filePathCallback, "");
+    }
+
+    protected void openFileChooser(ValueCallback<Uri> filePathCallback, String acceptType, String capture) {
+      this.mWebView.getThemedReactContext().getNativeModule(RNCWebViewModule.class).startPhotoPickerIntent(filePathCallback, acceptType);
+    }
+
+    @Override
+    public boolean onShowFileChooser(WebView webView, ValueCallback<Uri[]> filePathCallback, FileChooserParams fileChooserParams) {
+        String[] acceptTypes = fileChooserParams.getAcceptTypes();
+        boolean allowMultiple = fileChooserParams.getMode() == WebChromeClient.FileChooserParams.MODE_OPEN_MULTIPLE;
+
+        return this.mWebView.getThemedReactContext().getNativeModule(RNCWebViewModule.class).startPhotoPickerIntent(filePathCallback, acceptTypes, allowMultiple, fileChooserParams.isCaptureEnabled());
+    }
+
+    @Override
+    public void onHostResume() {
+        if (mVideoView != null && mVideoView.getSystemUiVisibility() != FULLSCREEN_SYSTEM_UI_VISIBILITY) {
+            mVideoView.setSystemUiVisibility(FULLSCREEN_SYSTEM_UI_VISIBILITY);
+        }
+    }
+
+    @Override
+    public void onHostPause() { }
+
+    @Override
+    public void onHostDestroy() { }
+
+    protected ViewGroup getRootView() {
+        return this.mWebView.getThemedReactContext().getCurrentActivity().findViewById(android.R.id.content);
+    }
+
+    public void setProgressChangedFilter(RNCWebView.ProgressChangedFilter filter) {
+        progressChangedFilter = filter;
+    }
+
+    /**
+     * Set whether or not protected media should be allowed
+     * /!\ Setting this to false won't revoke permission already granted to the current webpage.
+     * In order to do so, you'd need to reload the page /!\
+     */
+    public void setAllowsProtectedMedia(boolean enabled) {
+      mAllowsProtectedMedia = enabled;
+    }
+
+    public void setHasOnOpenWindowEvent(boolean hasEvent) {
+      mHasOnOpenWindowEvent = hasEvent;
+    }
+}