react-native-webview-bootpay 11.26.20 → 13.6.1

package/android/src/main/java/kr/co/bootpay/webview/BPCWebViewManager.java

@@ -1,910 +1,323 @@
 package kr.co.bootpay.webview;
 
-import android.annotation.SuppressLint;
-import android.annotation.TargetApi;
-import android.app.Activity;
-import android.app.DownloadManager;
-import android.content.Context;
-import android.content.pm.ActivityInfo;
-import android.content.pm.PackageManager;
-import android.graphics.Bitmap;
-import android.graphics.Color;
-import android.Manifest;
-import android.net.http.SslError;
-import android.net.Uri;
-import android.os.Build;
-import android.os.Environment;
-import android.os.Message;
-import android.os.SystemClock;
-import android.text.TextUtils;
-import android.util.Log;
-import android.view.Gravity;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.ViewGroup.LayoutParams;
-import android.view.WindowManager;
-import android.webkit.ConsoleMessage;
-import android.webkit.CookieManager;
-import android.webkit.DownloadListener;
-import android.webkit.GeolocationPermissions;
-import android.webkit.HttpAuthHandler;
-import android.webkit.JavascriptInterface;
-import android.webkit.RenderProcessGoneDetail;
-import android.webkit.SslErrorHandler;
-import android.webkit.PermissionRequest;
-import android.webkit.ValueCallback;
-import android.webkit.WebChromeClient;
-import android.webkit.WebResourceRequest;
-import android.webkit.WebResourceResponse;
-import android.webkit.WebSettings;
-import android.webkit.WebView;
-import android.webkit.WebViewClient;
-import android.widget.FrameLayout;
-
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.annotation.RequiresApi;
-import androidx.core.content.ContextCompat;
-import androidx.core.util.Pair;
-import androidx.webkit.WebSettingsCompat;
-import androidx.webkit.WebViewFeature;
-
-import com.facebook.common.logging.FLog;
-import com.facebook.react.modules.core.PermissionAwareActivity;
-import com.facebook.react.modules.core.PermissionListener;
-import com.facebook.react.views.scroll.ScrollEvent;
-import com.facebook.react.views.scroll.ScrollEventType;
-import com.facebook.react.views.scroll.OnScrollDispatchHelper;
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.CatalystInstance;
-import com.facebook.react.bridge.LifecycleEventListener;
-import com.facebook.react.bridge.ReactContext;
+
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.WritableNativeArray;
-import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.common.MapBuilder;
-import com.facebook.react.common.build.ReactBuildConfig;
-import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.SimpleViewManager;
 import com.facebook.react.uimanager.ThemedReactContext;
-import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.annotations.ReactProp;
-import com.facebook.react.uimanager.events.ContentSizeChangeEvent;
-import com.facebook.react.uimanager.events.Event;
-import com.facebook.react.uimanager.events.EventDispatcher;
-import kr.co.bootpay.webview.BPCWebViewModule.ShouldOverrideUrlLoadingLock.ShouldOverrideCallbackState;
-import kr.co.bootpay.webview.events.TopLoadingErrorEvent;
+import com.facebook.react.views.scroll.ScrollEventType;
+
+import java.util.Map;
+
+import kr.co.bootpay.webview.events.TopCustomMenuSelectionEvent;
 import kr.co.bootpay.webview.events.TopHttpErrorEvent;
+import kr.co.bootpay.webview.events.TopLoadingErrorEvent;
 import kr.co.bootpay.webview.events.TopLoadingFinishEvent;
 import kr.co.bootpay.webview.events.TopLoadingProgressEvent;
 import kr.co.bootpay.webview.events.TopLoadingStartEvent;
 import kr.co.bootpay.webview.events.TopMessageEvent;
-import kr.co.bootpay.webview.events.TopShouldStartLoadWithRequestEvent;
+import kr.co.bootpay.webview.events.TopOpenWindowEvent;
 import kr.co.bootpay.webview.events.TopRenderProcessGoneEvent;
+import kr.co.bootpay.webview.events.TopShouldStartLoadWithRequestEvent;
 
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.io.UnsupportedEncodingException;
-import java.lang.IllegalArgumentException;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.net.URLEncoder;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * Manages instances of {@link WebView}
- * <p>
- * Can accept following commands:
- * - GO_BACK
- * - GO_FORWARD
- * - RELOAD
- * - LOAD_URL
- * <p>
- * {@link WebView} instances could emit following direct events:
- * - topLoadingFinish
- * - topLoadingStart
- * - topLoadingStart
- * - topLoadingProgress
- * - topShouldStartLoadWithRequest
- * <p>
- * Each event will carry the following properties:
- * - target - view's react tag
- * - url - url set for the webview
- * - loading - whether webview is in a loading state
- * - title - title of the current page
- * - canGoBack - boolean, whether there is anything on a history stack to go back
- * - canGoForward - boolean, whether it is possible to request GO_FORWARD command
- */
-@ReactModule(name = BPCWebViewManager.REACT_CLASS)
-public class BPCWebViewManager extends SimpleViewManager<WebView> {
-  private static final String TAG = "BPCWebViewManager";
-
-  public static final int COMMAND_GO_BACK = 1;
-  public static final int COMMAND_GO_FORWARD = 2;
-  public static final int COMMAND_RELOAD = 3;
-  public static final int COMMAND_STOP_LOADING = 4;
-  public static final int COMMAND_POST_MESSAGE = 5;
-  public static final int COMMAND_INJECT_JAVASCRIPT = 6;
-  public static final int COMMAND_LOAD_URL = 7;
-  public static final int COMMAND_FOCUS = 8;
-
-  // android commands
-  public static final int COMMAND_CLEAR_FORM_DATA = 1000;
-  public static final int COMMAND_CLEAR_CACHE = 1001;
-  public static final int COMMAND_CLEAR_HISTORY = 1002;
-
-  protected static final String REACT_CLASS = "BPCWebView";
-  protected static final String HTML_ENCODING = "UTF-8";
-  protected static final String HTML_MIME_TYPE = "text/html";
-//  protected static final String JAVASCRIPT_INTERFACE = "ReactNativeWebView";
-  protected static final String HTTP_METHOD_POST = "POST";
-  // Use `webView.loadUrl("about:blank")` to reliably reset the view
-  // state and release page resources (including any running JavaScript).
-  protected static final String BLANK_URL = "about:blank";
-  protected static final int SHOULD_OVERRIDE_URL_LOADING_TIMEOUT = 250;
-  protected static final String DEFAULT_DOWNLOADING_MESSAGE = "Downloading";
-  protected static final String DEFAULT_LACK_PERMISSION_TO_DOWNLOAD_MESSAGE =
-    "Cannot download files as permission was denied. Please provide permission to write to storage, in order to download files.";
-  protected WebViewConfig mWebViewConfig;
-
-  protected BPCWebChromeClient mWebChromeClient = null;
-  protected boolean mAllowsFullscreenVideo = false;
-  protected boolean mAllowsProtectedMedia = false;
-  protected @Nullable String mUserAgent = null;
-  protected @Nullable String mUserAgentWithApplicationName = null;
-  protected @Nullable String mDownloadingMessage = null;
-  protected @Nullable String mLackPermissionToDownloadMessage = null;
-
-  public BPCWebViewManager() {
-    mWebViewConfig = new WebViewConfig() {
-      public void configWebView(WebView webView) {
-      }
-    };
-  }
-
-  public BPCWebViewManager(WebViewConfig webViewConfig) {
-    mWebViewConfig = webViewConfig;
-  }
-
-  @Override
-  public String getName() {
-    return REACT_CLASS;
-  }
-
-  protected BPCWebView createBPCWebViewInstance(ThemedReactContext reactContext) {
-    return new BPCWebView(reactContext);
-  }
-
-  @Override
-  @TargetApi(Build.VERSION_CODES.LOLLIPOP)
-  protected WebView createViewInstance(ThemedReactContext reactContext) {
-    BPCWebView webView = createBPCWebViewInstance(reactContext);
-    setupWebChromeClient(reactContext, webView);
-    reactContext.addLifecycleEventListener(webView);
-    mWebViewConfig.configWebView(webView);
-    WebSettings settings = webView.getSettings();
-    settings.setBuiltInZoomControls(true);
-    settings.setDisplayZoomControls(false);
-    settings.setDomStorageEnabled(true);
-    settings.setSupportMultipleWindows(true);
-
-    settings.setAllowFileAccess(false);
-    settings.setAllowContentAccess(false);
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-      settings.setAllowFileAccessFromFileURLs(false);
-      setAllowUniversalAccessFromFileURLs(webView, false);
-    }
-    setMixedContentMode(webView, "never");
-
-    // Fixes broken full-screen modals/galleries due to body height being 0.
-    webView.setLayoutParams(
-      new LayoutParams(LayoutParams.MATCH_PARENT,
-        LayoutParams.MATCH_PARENT));
-
-    if (ReactBuildConfig.DEBUG && Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
-      WebView.setWebContentsDebuggingEnabled(true);
-    }
-
-    webView.setDownloadListener(new DownloadListener() {
-      public void onDownloadStart(String url, String userAgent, String contentDisposition, String mimetype, long contentLength) {
-        webView.setIgnoreErrFailedForThisURL(url);
-
-        BPCWebViewModule module = getModule(reactContext);
-
-        DownloadManager.Request request;
-        try {
-          request = new DownloadManager.Request(Uri.parse(url));
-        } catch (IllegalArgumentException e) {
-          Log.w(TAG, "Unsupported URI, aborting download", e);
-          return;
-        }
+public class BPCWebViewManager extends SimpleViewManager<BPCWebView> {
 
-        String fileName = URLUtil.guessFileName(url, contentDisposition, mimetype);
-        String downloadMessage = "Downloading " + fileName;
-
-        //Attempt to add cookie, if it exists
-        URL urlObj = null;
-        try {
-          urlObj = new URL(url);
-          String baseUrl = urlObj.getProtocol() + "://" + urlObj.getHost();
-          String cookie = CookieManager.getInstance().getCookie(baseUrl);
-          request.addRequestHeader("Cookie", cookie);
-        } catch (MalformedURLException e) {
-          Log.w(TAG, "Error getting cookie for DownloadManager", e);
-        }
+    private final BPCWebViewManagerImpl mBPCWebViewManagerImpl;
 
-        //Finish setting up request
-        request.addRequestHeader("User-Agent", userAgent);
-        request.setTitle(fileName);
-        request.setDescription(downloadMessage);
-        request.allowScanningByMediaScanner();
-        request.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
-        request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileName);
+    public BPCWebViewManager() {
+        mBPCWebViewManagerImpl = new BPCWebViewManagerImpl();
+    }
 
-        module.setDownloadRequest(request);
+    @Override
+    public String getName() {
+        return BPCWebViewManagerImpl.NAME;
+    }
 
-        if (module.grantFileDownloaderPermissions(getDownloadingMessage(), getLackPermissionToDownloadMessage())) {
-          module.downloadFile(getDownloadingMessage());
-        }
-      }
-    });
-
-    return webView;
-  }
-
-  private String getDownloadingMessage() {
-    return  mDownloadingMessage == null ? DEFAULT_DOWNLOADING_MESSAGE : mDownloadingMessage;
-  }
-
-  private String getLackPermissionToDownloadMessage() {
-    return  mDownloadingMessage == null ? DEFAULT_LACK_PERMISSION_TO_DOWNLOAD_MESSAGE : mLackPermissionToDownloadMessage;
-  }
-
-  @ReactProp(name = "javaScriptEnabled")
-  public void setJavaScriptEnabled(WebView view, boolean enabled) {
-    view.getSettings().setJavaScriptEnabled(enabled);
-  }
-
-  @ReactProp(name = "setBuiltInZoomControls")
-  public void setBuiltInZoomControls(WebView view, boolean enabled) {
-    view.getSettings().setBuiltInZoomControls(enabled);
-  }
-
-  @ReactProp(name = "setDisplayZoomControls")
-  public void setDisplayZoomControls(WebView view, boolean enabled) {
-    view.getSettings().setDisplayZoomControls(enabled);
-  }
-
-  @ReactProp(name = "setSupportMultipleWindows")
-  public void setSupportMultipleWindows(WebView view, boolean enabled){
-    view.getSettings().setSupportMultipleWindows(enabled);
-  }
-
-  @ReactProp(name = "showsHorizontalScrollIndicator")
-  public void setShowsHorizontalScrollIndicator(WebView view, boolean enabled) {
-    view.setHorizontalScrollBarEnabled(enabled);
-  }
-
-  @ReactProp(name = "showsVerticalScrollIndicator")
-  public void setShowsVerticalScrollIndicator(WebView view, boolean enabled) {
-    view.setVerticalScrollBarEnabled(enabled);
-  }
-
-  @ReactProp(name = "downloadingMessage")
-  public void setDownloadingMessage(WebView view, String message) {
-    mDownloadingMessage = message;
-  }
-
-  @ReactProp(name = "lackPermissionToDownloadMessage")
-  public void setLackPermissionToDownlaodMessage(WebView view, String message) {
-    mLackPermissionToDownloadMessage = message;
-  }
-
-  @ReactProp(name = "cacheEnabled")
-  public void setCacheEnabled(WebView view, boolean enabled) {
-    view.getSettings().setCacheMode(enabled ? WebSettings.LOAD_DEFAULT : WebSettings.LOAD_NO_CACHE);
-  }
-
-  @ReactProp(name = "cacheMode")
-  public void setCacheMode(WebView view, String cacheModeString) {
-    Integer cacheMode;
-    switch (cacheModeString) {
-      case "LOAD_CACHE_ONLY":
-        cacheMode = WebSettings.LOAD_CACHE_ONLY;
-        break;
-      case "LOAD_CACHE_ELSE_NETWORK":
-        cacheMode = WebSettings.LOAD_CACHE_ELSE_NETWORK;
-        break;
-      case "LOAD_NO_CACHE":
-        cacheMode = WebSettings.LOAD_NO_CACHE;
-        break;
-      case "LOAD_DEFAULT":
-      default:
-        cacheMode = WebSettings.LOAD_DEFAULT;
-        break;
-    }
-    view.getSettings().setCacheMode(cacheMode);
-  }
-
-  @ReactProp(name = "androidHardwareAccelerationDisabled")
-  public void setHardwareAccelerationDisabled(WebView view, boolean disabled) {
-    if (disabled) {
-      view.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
-    }
-  }
-
-  @ReactProp(name = "androidLayerType")
-  public void setLayerType(WebView view, String layerTypeString) {
-    int layerType = View.LAYER_TYPE_NONE;
-    switch (layerTypeString) {
-        case "hardware":
-          layerType = View.LAYER_TYPE_HARDWARE;
-          break;
-        case "software":
-          layerType = View.LAYER_TYPE_SOFTWARE;
-          break;
-    }
-    view.setLayerType(layerType, null);
-  }
-
-
-  @ReactProp(name = "overScrollMode")
-  public void setOverScrollMode(WebView view, String overScrollModeString) {
-    Integer overScrollMode;
-    switch (overScrollModeString) {
-      case "never":
-        overScrollMode = View.OVER_SCROLL_NEVER;
-        break;
-      case "content":
-        overScrollMode = View.OVER_SCROLL_IF_CONTENT_SCROLLS;
-        break;
-      case "always":
-      default:
-        overScrollMode = View.OVER_SCROLL_ALWAYS;
-        break;
-    }
-    view.setOverScrollMode(overScrollMode);
-  }
-
-  @ReactProp(name = "nestedScrollEnabled")
-  public void setNestedScrollEnabled(WebView view, boolean enabled) {
-    ((BPCWebView) view).setNestedScrollEnabled(enabled);
-  }
-
-  @ReactProp(name = "thirdPartyCookiesEnabled")
-  public void setThirdPartyCookiesEnabled(WebView view, boolean enabled) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-      CookieManager.getInstance().setAcceptThirdPartyCookies(view, enabled);
-    }
-  }
-
-  @ReactProp(name = "textZoom")
-  public void setTextZoom(WebView view, int value) {
-    view.getSettings().setTextZoom(value);
-  }
-
-  @ReactProp(name = "scalesPageToFit")
-  public void setScalesPageToFit(WebView view, boolean enabled) {
-    view.getSettings().setLoadWithOverviewMode(enabled);
-    view.getSettings().setUseWideViewPort(enabled);
-  }
-
-  @ReactProp(name = "domStorageEnabled")
-  public void setDomStorageEnabled(WebView view, boolean enabled) {
-    view.getSettings().setDomStorageEnabled(enabled);
-  }
-
-  @ReactProp(name = "userAgent")
-  public void setUserAgent(WebView view, @Nullable String userAgent) {
-    if (userAgent != null) {
-      mUserAgent = userAgent;
-    } else {
-      mUserAgent = null;
-    }
-    this.setUserAgentString(view);
-  }
-
-  @ReactProp(name = "applicationNameForUserAgent")
-  public void setApplicationNameForUserAgent(WebView view, @Nullable String applicationName) {
-    if(applicationName != null) {
-      if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-        String defaultUserAgent = WebSettings.getDefaultUserAgent(view.getContext());
-        mUserAgentWithApplicationName = defaultUserAgent + " " + applicationName;
-      }
-    } else {
-      mUserAgentWithApplicationName = null;
-    }
-    this.setUserAgentString(view);
-  }
-
-  protected void setUserAgentString(WebView view) {
-    if(mUserAgent != null) {
-      view.getSettings().setUserAgentString(mUserAgent);
-    } else if(mUserAgentWithApplicationName != null) {
-      view.getSettings().setUserAgentString(mUserAgentWithApplicationName);
-    } else if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-      // handle unsets of `userAgent` prop as long as device is >= API 17
-      view.getSettings().setUserAgentString(WebSettings.getDefaultUserAgent(view.getContext()));
-    }
-  }
-
-  @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
-  @ReactProp(name = "mediaPlaybackRequiresUserAction")
-  public void setMediaPlaybackRequiresUserAction(WebView view, boolean requires) {
-    view.getSettings().setMediaPlaybackRequiresUserGesture(requires);
-  }
-
-  @ReactProp(name = "javaScriptCanOpenWindowsAutomatically")
-  public void setJavaScriptCanOpenWindowsAutomatically(WebView view, boolean enabled) {
-    view.getSettings().setJavaScriptCanOpenWindowsAutomatically(enabled);
-  }
-
-  @ReactProp(name = "allowFileAccessFromFileURLs")
-  public void setAllowFileAccessFromFileURLs(WebView view, boolean allow) {
-    view.getSettings().setAllowFileAccessFromFileURLs(allow);
-  }
-
-  @ReactProp(name = "allowUniversalAccessFromFileURLs")
-  public void setAllowUniversalAccessFromFileURLs(WebView view, boolean allow) {
-    view.getSettings().setAllowUniversalAccessFromFileURLs(allow);
-  }
-
-  @ReactProp(name = "saveFormDataDisabled")
-  public void setSaveFormDataDisabled(WebView view, boolean disable) {
-    view.getSettings().setSaveFormData(!disable);
-  }
-
-  @ReactProp(name = "injectedJavaScript")
-  public void setInjectedJavaScript(WebView view, @Nullable String injectedJavaScript) {
-    ((BPCWebView) view).setInjectedJavaScript(injectedJavaScript);
-  }
-
-  @ReactProp(name = "injectedJavaScriptBeforeContentLoaded")
-  public void setInjectedJavaScriptBeforeContentLoaded(WebView view, @Nullable String injectedJavaScriptBeforeContentLoaded) {
-    ((BPCWebView) view).setInjectedJavaScriptBeforeContentLoaded(injectedJavaScriptBeforeContentLoaded);
-  }
-
-  @ReactProp(name = "injectedJavaScriptForMainFrameOnly")
-  public void setInjectedJavaScriptForMainFrameOnly(WebView view, boolean enabled) {
-    ((BPCWebView) view).setInjectedJavaScriptForMainFrameOnly(enabled);
-  }
-
-  @ReactProp(name = "injectedJavaScriptBeforeContentLoadedForMainFrameOnly")
-  public void setInjectedJavaScriptBeforeContentLoadedForMainFrameOnly(WebView view, boolean enabled) {
-    ((BPCWebView) view).setInjectedJavaScriptBeforeContentLoadedForMainFrameOnly(enabled);
-  }
-
-  @ReactProp(name = "messagingEnabled")
-  public void setMessagingEnabled(WebView view, boolean enabled) {
-    ((BPCWebView) view).setMessagingEnabled(enabled);
-  }
-
-  @ReactProp(name = "messagingModuleName")
-  public void setMessagingModuleName(WebView view, String moduleName) {
-    ((BPCWebView) view).setMessagingModuleName(moduleName);
-  }
-
-  @ReactProp(name = "incognito")
-  public void setIncognito(WebView view, boolean enabled) {
-    // Don't do anything when incognito is disabled
-    if (!enabled) {
-      return;
-    }
-
-    // Remove all previous cookies
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-      CookieManager.getInstance().removeAllCookies(null);
-    } else {
-      CookieManager.getInstance().removeAllCookie();
-    }
-
-    // Disable caching
-    view.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);
-    view.clearHistory();
-    view.clearCache(true);
-
-    // No form data or autofill enabled
-    view.clearFormData();
-    view.getSettings().setSavePassword(false);
-    view.getSettings().setSaveFormData(false);
-  }
-
-  @ReactProp(name = "source")
-  public void setSource(WebView view, @Nullable ReadableMap source) {
-    if (source != null) {
-      if (source.hasKey("html")) {
-        String html = source.getString("html");
-        String baseUrl = source.hasKey("baseUrl") ? source.getString("baseUrl") : "";
-        view.loadDataWithBaseURL(baseUrl, html, HTML_MIME_TYPE, HTML_ENCODING, null);
-        return;
-      }
-      if (source.hasKey("uri")) {
-        String url = source.getString("uri");
-        String previousUrl = view.getUrl();
-        if (previousUrl != null && previousUrl.equals(url)) {
-          return;
-        }
-        if (source.hasKey("method")) {
-          String method = source.getString("method");
-          if (method.equalsIgnoreCase(HTTP_METHOD_POST)) {
-            byte[] postData = null;
-            if (source.hasKey("body")) {
-              String body = source.getString("body");
-              try {
-                postData = body.getBytes("UTF-8");
-              } catch (UnsupportedEncodingException e) {
-                postData = body.getBytes();
-              }
-            }
-            if (postData == null) {
-              postData = new byte[0];
-            }
-            view.postUrl(url, postData);
-            return;
-          }
-        }
-        HashMap<String, String> headerMap = new HashMap<>();
-        if (source.hasKey("headers")) {
-          ReadableMap headers = source.getMap("headers");
-          ReadableMapKeySetIterator iter = headers.keySetIterator();
-          while (iter.hasNextKey()) {
-            String key = iter.nextKey();
-            if ("user-agent".equals(key.toLowerCase(Locale.ENGLISH))) {
-              if (view.getSettings() != null) {
-                view.getSettings().setUserAgentString(headers.getString(key));
-              }
-            } else {
-              headerMap.put(key, headers.getString(key));
-            }
-          }
-        }
-        view.loadUrl(url, headerMap);
-        return;
-      }
-    }
-    view.loadUrl(BLANK_URL);
-  }
-
-  @ReactProp(name = "basicAuthCredential")
-  public void setBasicAuthCredential(WebView view, @Nullable ReadableMap credential) {
-    @Nullable BasicAuthCredential basicAuthCredential = null;
-    if (credential != null) {
-      if (credential.hasKey("username") && credential.hasKey("password")) {
-        String username = credential.getString("username");
-        String password = credential.getString("password");
-        basicAuthCredential = new BasicAuthCredential(username, password);
-      }
-    }
-    ((BPCWebView) view).setBasicAuthCredential(basicAuthCredential);
-  }
-
-  @ReactProp(name = "onContentSizeChange")
-  public void setOnContentSizeChange(WebView view, boolean sendContentSizeChangeEvents) {
-    ((BPCWebView) view).setSendContentSizeChangeEvents(sendContentSizeChangeEvents);
-  }
-
-  @ReactProp(name = "mixedContentMode")
-  public void setMixedContentMode(WebView view, @Nullable String mixedContentMode) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-      if (mixedContentMode == null || "never".equals(mixedContentMode)) {
-        view.getSettings().setMixedContentMode(WebSettings.MIXED_CONTENT_NEVER_ALLOW);
-      } else if ("always".equals(mixedContentMode)) {
-        view.getSettings().setMixedContentMode(WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
-      } else if ("compatibility".equals(mixedContentMode)) {
-        view.getSettings().setMixedContentMode(WebSettings.MIXED_CONTENT_COMPATIBILITY_MODE);
-      }
-    }
-  }
-
-  @ReactProp(name = "urlPrefixesForDefaultIntent")
-  public void setUrlPrefixesForDefaultIntent(
-    WebView view,
-    @Nullable ReadableArray urlPrefixesForDefaultIntent) {
-    BPCWebViewClient client = ((BPCWebView) view).getBPCWebViewClient();
-    if (client != null && urlPrefixesForDefaultIntent != null) {
-      client.setUrlPrefixesForDefaultIntent(urlPrefixesForDefaultIntent);
-    }
-  }
-
-  @ReactProp(name = "allowsFullscreenVideo")
-  public void setAllowsFullscreenVideo(
-    WebView view,
-    @Nullable Boolean allowsFullscreenVideo) {
-    mAllowsFullscreenVideo = allowsFullscreenVideo != null && allowsFullscreenVideo;
-    setupWebChromeClient((ReactContext)view.getContext(), view);
-  }
-
-  @ReactProp(name = "allowFileAccess")
-  public void setAllowFileAccess(
-    WebView view,
-    @Nullable Boolean allowFileAccess) {
-    view.getSettings().setAllowFileAccess(allowFileAccess != null && allowFileAccess);
-  }
-
-  @ReactProp(name = "geolocationEnabled")
-  public void setGeolocationEnabled(
-    WebView view,
-    @Nullable Boolean isGeolocationEnabled) {
-    view.getSettings().setGeolocationEnabled(isGeolocationEnabled != null && isGeolocationEnabled);
-  }
-
-  @ReactProp(name = "onScroll")
-  public void setOnScroll(WebView view, boolean hasScrollEvent) {
-    ((BPCWebView) view).setHasScrollEvent(hasScrollEvent);
-  }
-
-  @ReactProp(name = "forceDarkOn")
-  public void setForceDarkOn(WebView view, boolean enabled) {
-    // Only Android 10+ support dark mode
-    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
-      // Switch WebView dark mode
-      if (WebViewFeature.isFeatureSupported(WebViewFeature.FORCE_DARK)) {
-        int forceDarkMode = enabled ? WebSettingsCompat.FORCE_DARK_ON : WebSettingsCompat.FORCE_DARK_OFF;
-        WebSettingsCompat.setForceDark(view.getSettings(), forceDarkMode);
-      }
-
-      // Set how WebView content should be darkened.
-      // PREFER_WEB_THEME_OVER_USER_AGENT_DARKENING:  checks for the "color-scheme" <meta> tag.
-      // If present, it uses media queries. If absent, it applies user-agent (automatic)
-      // More information about Force Dark Strategy can be found here:
-      // https://developer.android.com/reference/androidx/webkit/WebSettingsCompat#setForceDarkStrategy(android.webkit.WebSettings)
-      if (enabled && WebViewFeature.isFeatureSupported(WebViewFeature.FORCE_DARK_STRATEGY)) {
-        WebSettingsCompat.setForceDarkStrategy(view.getSettings(), WebSettingsCompat.DARK_STRATEGY_PREFER_WEB_THEME_OVER_USER_AGENT_DARKENING);
-      }
-    }
-  }
-
-  @ReactProp(name = "minimumFontSize")
-  public void setMinimumFontSize(WebView view, int fontSize) {
-    view.getSettings().setMinimumFontSize(fontSize);
-  }
-
-  @ReactProp(name = "allowsProtectedMedia")
-  public void setAllowsProtectedMedia(WebView view, boolean enabled) {
-    // This variable is used to keep consistency
-    // in case a new WebChromeClient is created
-    // (eg. when mAllowsFullScreenVideo changes)
-    mAllowsProtectedMedia = enabled;
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        WebChromeClient client = view.getWebChromeClient();
-        if (client != null && client instanceof BPCWebChromeClient) {
-            ((BPCWebChromeClient) client).setAllowsProtectedMedia(enabled);
-        }
+    @Override
+    public BPCWebView createViewInstance(ThemedReactContext context) {
+        return mBPCWebViewManagerImpl.createViewInstance(context);
     }
-  }
-
-  @Override
-  protected void addEventEmitters(ThemedReactContext reactContext, WebView view) {
-    // Do not register default touch emitter and let WebView implementation handle touches
-    view.setWebViewClient(new BPCWebViewClient());
-  }
-
-  @Override
-  public Map getExportedCustomDirectEventTypeConstants() {
-    Map export = super.getExportedCustomDirectEventTypeConstants();
-    if (export == null) {
-      export = MapBuilder.newHashMap();
-    }
-    // Default events but adding them here explicitly for clarity
-    export.put(TopLoadingStartEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingStart"));
-    export.put(TopLoadingFinishEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingFinish"));
-    export.put(TopLoadingErrorEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingError"));
-    export.put(TopMessageEvent.EVENT_NAME, MapBuilder.of("registrationName", "onMessage"));
-    // !Default events but adding them here explicitly for clarity
-
-    export.put(TopLoadingProgressEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingProgress"));
-    export.put(TopShouldStartLoadWithRequestEvent.EVENT_NAME, MapBuilder.of("registrationName", "onShouldStartLoadWithRequest"));
-    export.put(ScrollEventType.getJSEventName(ScrollEventType.SCROLL), MapBuilder.of("registrationName", "onScroll"));
-    export.put(TopHttpErrorEvent.EVENT_NAME, MapBuilder.of("registrationName", "onHttpError"));
-    export.put(TopRenderProcessGoneEvent.EVENT_NAME, MapBuilder.of("registrationName", "onRenderProcessGone"));
-    return export;
-  }
-
-  @Override
-  public @Nullable
-  Map<String, Integer> getCommandsMap() {
-    return MapBuilder.<String, Integer>builder()
-      .put("goBack", COMMAND_GO_BACK)
-      .put("goForward", COMMAND_GO_FORWARD)
-      .put("reload", COMMAND_RELOAD)
-      .put("stopLoading", COMMAND_STOP_LOADING)
-      .put("postMessage", COMMAND_POST_MESSAGE)
-      .put("injectJavaScript", COMMAND_INJECT_JAVASCRIPT)
-      .put("loadUrl", COMMAND_LOAD_URL)
-      .put("requestFocus", COMMAND_FOCUS)
-      .put("clearFormData", COMMAND_CLEAR_FORM_DATA)
-      .put("clearCache", COMMAND_CLEAR_CACHE)
-      .put("clearHistory", COMMAND_CLEAR_HISTORY)
-      .build();
-  }
-
-  @Override
-  public void receiveCommand(@NonNull WebView root, String commandId, @Nullable ReadableArray args) {
-    switch (commandId) {
-      case "goBack":
-        root.goBack();
-        break;
-      case "goForward":
-        root.goForward();
-        break;
-      case "reload":
-        root.reload();
-        break;
-      case "stopLoading":
-        root.stopLoading();
-        break;
-      case "postMessage":
-        try {
-          BPCWebView reactWebView = (BPCWebView) root;
-          JSONObject eventInitDict = new JSONObject();
-          eventInitDict.put("data", args.getString(0));
-          reactWebView.evaluateJavascriptWithFallback("(function () {" +
-            "var event;" +
-            "var data = " + eventInitDict.toString() + ";" +
-            "try {" +
-            "event = new MessageEvent('message', data);" +
-            "} catch (e) {" +
-            "event = document.createEvent('MessageEvent');" +
-            "event.initMessageEvent('message', true, true, data.data, data.origin, data.lastEventId, data.source);" +
-            "}" +
-            "document.dispatchEvent(event);" +
-            "})();");
-        } catch (JSONException e) {
-          throw new RuntimeException(e);
-        }
-        break;
-      case "injectJavaScript":
-        BPCWebView reactWebView = (BPCWebView) root;
-        reactWebView.evaluateJavascriptWithFallback(args.getString(0));
-        break;
-      case "loadUrl":
-        if (args == null) {
-          throw new RuntimeException("Arguments for loading an url are null!");
-        }
-        ((BPCWebView) root).progressChangedFilter.setWaitingForCommandLoadUrl(false);
-        root.loadUrl(args.getString(0));
-        break;
-      case "requestFocus":
-        root.requestFocus();
-        break;
-      case "clearFormData":
-        root.clearFormData();
-        break;
-      case "clearCache":
-        boolean includeDiskFiles = args != null && args.getBoolean(0);
-        root.clearCache(includeDiskFiles);
-        break;
-      case "clearHistory":
-        root.clearHistory();
-        break;
-    }
-    super.receiveCommand(root, commandId, args);
-  }
-
-  @Override
-  public void onDropViewInstance(WebView webView) {
-    super.onDropViewInstance(webView);
-    ((ThemedReactContext) webView.getContext()).removeLifecycleEventListener((BPCWebView) webView);
-    ((BPCWebView) webView).cleanupCallbacksAndDestroy();
-    mWebChromeClient = null;
-  }
-
-  public static BPCWebViewModule getModule(ReactContext reactContext) {
-    return reactContext.getNativeModule(BPCWebViewModule.class);
-  }
-
-  protected void setupWebChromeClient(ReactContext reactContext, WebView webView) {
-    Activity activity = reactContext.getCurrentActivity();
-
-    if (mAllowsFullscreenVideo && activity != null) {
-      int initialRequestedOrientation = activity.getRequestedOrientation();
-
-      mWebChromeClient = new BPCWebChromeClient(reactContext, webView) {
-        @Override
-        public Bitmap getDefaultVideoPoster() {
-          return Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888);
-        }
 
-        @Override
-        public void onShowCustomView(View view, CustomViewCallback callback) {
-          if (mVideoView != null) {
-            callback.onCustomViewHidden();
-            return;
-          }
-
-          mVideoView = view;
-          mCustomViewCallback = callback;
-
-          activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
-
-          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
-            mVideoView.setSystemUiVisibility(FULLSCREEN_SYSTEM_UI_VISIBILITY);
-            activity.getWindow().setFlags(
-              WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS,
-              WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
-            );
-          }
-
-          mVideoView.setBackgroundColor(Color.BLACK);
-
-          // Since RN's Modals interfere with the View hierarchy
-          // we will decide which View to hide if the hierarchy
-          // does not match (i.e., the WebView is within a Modal)
-          // NOTE: We could use `mWebView.getRootView()` instead of `getRootView()`
-          // but that breaks the Modal's styles and layout, so we need this to render
-          // in the main View hierarchy regardless
-          ViewGroup rootView = getRootView();
-          rootView.addView(mVideoView, FULLSCREEN_LAYOUT_PARAMS);
-
-          // Different root views, we are in a Modal
-          if (rootView.getRootView() != mWebView.getRootView()) {
-            mWebView.getRootView().setVisibility(View.GONE);
-          } else {
-            // Same view hierarchy (no Modal), just hide the WebView then
-            mWebView.setVisibility(View.GONE);
-          }
-
-          mReactContext.addLifecycleEventListener(this);
-        }
+    public BPCWebView createViewInstance(ThemedReactContext context, BPCWebView webView) {
+      return mBPCWebViewManagerImpl.createViewInstance(context, webView);
+    }
 
-        @Override
-        public void onHideCustomView() {
-          if (mVideoView == null) {
-            return;
-          }
+    @ReactProp(name = "allowFileAccess")
+    public void setAllowFileAccess(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setAllowFileAccess(view, value);
+    }
 
-          // Same logic as above
-          ViewGroup rootView = getRootView();
+    @ReactProp(name = "allowFileAccessFromFileURLs")
+    public void setAllowFileAccessFromFileURLs(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setAllowFileAccessFromFileURLs(view, value);
 
-          if (rootView.getRootView() != mWebView.getRootView()) {
-            mWebView.getRootView().setVisibility(View.VISIBLE);
-          } else {
-            // Same view hierarchy (no Modal)
-            mWebView.setVisibility(View.VISIBLE);
-          }
+    }
 
-          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
-            activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
-          }
+    @ReactProp(name = "allowUniversalAccessFromFileURLs")
+    public void setAllowUniversalAccessFromFileURLs(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setAllowUniversalAccessFromFileURLs(view, value);
+    }
 
-          rootView.removeView(mVideoView);
-          mCustomViewCallback.onCustomViewHidden();
+    @ReactProp(name = "allowsFullscreenVideo")
+    public void setAllowsFullscreenVideo(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setAllowsFullscreenVideo(view, value);
+    }
 
-          mVideoView = null;
-          mCustomViewCallback = null;
+    @ReactProp(name = "allowsProtectedMedia")
+    public void setAllowsProtectedMedia(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setAllowsProtectedMedia(view, value);
+    }
 
-          activity.setRequestedOrientation(initialRequestedOrientation);
+    @ReactProp(name = "androidLayerType")
+    public void setAndroidLayerType(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setAndroidLayerType(view, value);
+    }
 
-          mReactContext.removeLifecycleEventListener(this);
-        }
-      };
-
-      // bootpay added //
-      webView.setWebChromeClient(mWebChromeClient);
-    } else {
-      if (mWebChromeClient != null) {
-        mWebChromeClient.onHideCustomView();
-      }
-
-      mWebChromeClient = new BPCWebChromeClient(reactContext, webView) {
-        @Override
-        public Bitmap getDefaultVideoPoster() {
-          return Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888);
+    @ReactProp(name = "applicationNameForUserAgent")
+    public void setApplicationNameForUserAgent(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setApplicationNameForUserAgent(view, value);
+    }
+
+    @ReactProp(name = "basicAuthCredential")
+    public void setBasicAuthCredential(BPCWebView view, @Nullable ReadableMap value) {
+        mBPCWebViewManagerImpl.setBasicAuthCredential(view, value);
+    }
+
+    @ReactProp(name = "cacheEnabled")
+    public void setCacheEnabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setCacheEnabled(view, value);
+    }
+
+    @ReactProp(name = "cacheMode")
+    public void setCacheMode(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setCacheMode(view, value);
+    }
+
+    @ReactProp(name = "domStorageEnabled")
+    public void setDomStorageEnabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setDomStorageEnabled(view, value);
+    }
+
+    @ReactProp(name = "downloadingMessage")
+    public void setDownloadingMessage(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setDownloadingMessage(value);
+    }
+
+    @ReactProp(name = "forceDarkOn")
+    public void setForceDarkOn(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setForceDarkOn(view, value);
+    }
+
+    @ReactProp(name = "geolocationEnabled")
+    public void setGeolocationEnabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setGeolocationEnabled(view, value);
+    }
+
+    @ReactProp(name = "hasOnScroll")
+    public void setHasOnScroll(BPCWebView view, boolean hasScrollEvent) {
+        mBPCWebViewManagerImpl.setHasOnScroll(view, hasScrollEvent);
+    }
+
+    @ReactProp(name = "incognito")
+    public void setIncognito(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setIncognito(view, value);
+    }
+
+    @ReactProp(name = "injectedJavaScript")
+    public void setInjectedJavaScript(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setInjectedJavaScript(view, value);
+    }
+
+    @ReactProp(name = "injectedJavaScriptBeforeContentLoaded")
+    public void setInjectedJavaScriptBeforeContentLoaded(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setInjectedJavaScriptBeforeContentLoaded(view, value);
+    }
+
+    @ReactProp(name = "injectedJavaScriptForMainFrameOnly")
+    public void setInjectedJavaScriptForMainFrameOnly(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setInjectedJavaScriptForMainFrameOnly(view, value);
+
+    }
+
+    @ReactProp(name = "injectedJavaScriptBeforeContentLoadedForMainFrameOnly")
+    public void setInjectedJavaScriptBeforeContentLoadedForMainFrameOnly(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setInjectedJavaScriptBeforeContentLoadedForMainFrameOnly(view, value);
+
+    }
+
+    @ReactProp(name = "injectedJavaScriptObject")
+    public void setInjectedJavaScriptObject(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setInjectedJavaScriptObject(view, value);
+    }
+
+    @ReactProp(name = "javaScriptCanOpenWindowsAutomatically")
+    public void setJavaScriptCanOpenWindowsAutomatically(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setJavaScriptCanOpenWindowsAutomatically(view, value);
+    }
+
+    @ReactProp(name = "javaScriptEnabled")
+    public void setJavaScriptEnabled(BPCWebView view, boolean enabled) {
+        mBPCWebViewManagerImpl.setJavaScriptEnabled(view, enabled);
+    }
+
+    @ReactProp(name = "lackPermissionToDownloadMessage")
+    public void setLackPermissionToDownloadMessage(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setLackPermissionToDownloadMessage(value);
+    }
+
+    @ReactProp(name = "hasOnOpenWindowEvent")
+    public void setHasOnOpenWindowEvent(BPCWebView view, boolean hasEvent) {
+        mBPCWebViewManagerImpl.setHasOnOpenWindowEvent(view, hasEvent);
+    }
+
+    @ReactProp(name = "mediaPlaybackRequiresUserAction")
+    public void setMediaPlaybackRequiresUserAction(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setMediaPlaybackRequiresUserAction(view, value);
+    }
+
+    @ReactProp(name = "messagingEnabled")
+    public void setMessagingEnabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setMessagingEnabled(view, value);
+    }
+
+    @ReactProp(name = "menuItems")
+    public void setMenuCustomItems(BPCWebView view, @Nullable ReadableArray items) {
+        mBPCWebViewManagerImpl.setMenuCustomItems(view, items);
+    }
+
+    @ReactProp(name = "messagingModuleName")
+    public void setMessagingModuleName(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setMessagingModuleName(view, value);
+    }
+
+    @ReactProp(name = "minimumFontSize")
+    public void setMinimumFontSize(BPCWebView view, int value) {
+        mBPCWebViewManagerImpl.setMinimumFontSize(view, value);
+    }
+
+    @ReactProp(name = "mixedContentMode")
+    public void setMixedContentMode(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setMixedContentMode(view, value);
+    }
+
+    @ReactProp(name = "nestedScrollEnabled")
+    public void setNestedScrollEnabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setNestedScrollEnabled(view, value);
+    }
+
+    @ReactProp(name = "overScrollMode")
+    public void setOverScrollMode(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setOverScrollMode(view, value);
+    }
+
+    @ReactProp(name = "saveFormDataDisabled")
+    public void setSaveFormDataDisabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setSaveFormDataDisabled(view, value);
+    }
+
+    @ReactProp(name = "scalesPageToFit")
+    public void setScalesPageToFit(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setScalesPageToFit(view, value);
+    }
+
+    @ReactProp(name = "setBuiltInZoomControls")
+    public void setSetBuiltInZoomControls(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setSetBuiltInZoomControls(view, value);
+    }
+
+    @ReactProp(name = "setDisplayZoomControls")
+    public void setSetDisplayZoomControls(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setSetDisplayZoomControls(view, value);
+    }
+
+    @ReactProp(name = "setSupportMultipleWindows")
+    public void setSetSupportMultipleWindows(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setSetSupportMultipleWindows(view, value);
+    }
+
+    @ReactProp(name = "showsHorizontalScrollIndicator")
+    public void setShowsHorizontalScrollIndicator(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setShowsHorizontalScrollIndicator(view, value);
+    }
+
+    @ReactProp(name = "showsVerticalScrollIndicator")
+    public void setShowsVerticalScrollIndicator(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setShowsVerticalScrollIndicator(view, value);
+    }
+
+    @ReactProp(name = "source")
+    public void setSource(BPCWebView view, @Nullable ReadableMap value) {
+        mBPCWebViewManagerImpl.setSource(view, value, false);
+    }
+
+    @ReactProp(name = "textZoom")
+    public void setTextZoom(BPCWebView view, int value) {
+        mBPCWebViewManagerImpl.setTextZoom(view, value);
+    }
+
+    @ReactProp(name = "thirdPartyCookiesEnabled")
+    public void setThirdPartyCookiesEnabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setThirdPartyCookiesEnabled(view, value);
+    }
+
+    @ReactProp(name = "webviewDebuggingEnabled")
+    public void setWebviewDebuggingEnabled(BPCWebView view, boolean value) {
+        mBPCWebViewManagerImpl.setWebviewDebuggingEnabled(view, value);
+    }
+
+    @ReactProp(name = "userAgent")
+    public void setUserAgent(BPCWebView view, @Nullable String value) {
+        mBPCWebViewManagerImpl.setUserAgent(view, value);
+    }
+
+    @Override
+    protected void addEventEmitters(@NonNull ThemedReactContext reactContext, BPCWebView view) {
+        // Do not register default touch emitter and let WebView implementation handle touches
+        view.setWebViewClient(new BPCWebViewClient());
+    }
+
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        Map<String, Object> export = super.getExportedCustomDirectEventTypeConstants();
+        if (export == null) {
+            export = MapBuilder.newHashMap();
         }
-      };
+        // Default events but adding them here explicitly for clarity
+        export.put(TopLoadingStartEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingStart"));
+        export.put(TopLoadingFinishEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingFinish"));
+        export.put(TopLoadingErrorEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingError"));
+        export.put(TopMessageEvent.EVENT_NAME, MapBuilder.of("registrationName", "onMessage"));
+        // !Default events but adding them here explicitly for clarity
+
+        export.put(TopLoadingProgressEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingProgress"));
+        export.put(TopShouldStartLoadWithRequestEvent.EVENT_NAME, MapBuilder.of("registrationName", "onShouldStartLoadWithRequest"));
+        export.put(ScrollEventType.getJSEventName(ScrollEventType.SCROLL), MapBuilder.of("registrationName", "onScroll"));
+        export.put(TopHttpErrorEvent.EVENT_NAME, MapBuilder.of("registrationName", "onHttpError"));
+        export.put(TopRenderProcessGoneEvent.EVENT_NAME, MapBuilder.of("registrationName", "onRenderProcessGone"));
+        export.put(TopCustomMenuSelectionEvent.EVENT_NAME, MapBuilder.of("registrationName", "onCustomMenuSelection"));
+        export.put(TopOpenWindowEvent.EVENT_NAME, MapBuilder.of("registrationName", "onOpenWindow"));
+        return export;
+    }
+
+    @Override
+    public @Nullable
+    Map<String, Integer> getCommandsMap() {
+        return mBPCWebViewManagerImpl.getCommandsMap();
+    }
+
+    @Override
+    public void receiveCommand(@NonNull BPCWebView reactWebView, String commandId, @Nullable ReadableArray args) {
+        mBPCWebViewManagerImpl.receiveCommand(reactWebView, commandId, args);
+        super.receiveCommand(reactWebView, commandId, args);
+    }
+
+    @Override
+    public void onDropViewInstance(@NonNull BPCWebView view) {
+        mBPCWebViewManagerImpl.onDropViewInstance(view);
+        super.onDropViewInstance(view);
     }
-    mWebChromeClient.setAllowsProtectedMedia(mAllowsProtectedMedia);
-    webView.setWebChromeClient(mWebChromeClient);
-  }
-}
+}