@javascriptcommon/react-native-webview 13.12.21 → 13.17.0

package/android/src/main/java/com/reactnativecommunity/webview/ContentFilter.kt

@@ -0,0 +1,85 @@
+package com.reactnativecommunity.webview
+
+import android.content.Context
+import android.util.Log
+
+/**
+ * Kotlin bridge to the native content-filtering engine (`libcontentfilter.so`).
+ *
+ * The engine is a single, process-wide, immutable rule set. It is initialised
+ * once, lazily, on a background thread from a bundled rule-list text asset.
+ * Everything fails OPEN: if the library cannot be loaded, the asset is missing,
+ * or the engine is not ready yet, [shouldBlock] returns false and requests load
+ * normally.
+ *
+ * Matching itself (`nativeCheck`) is serialized behind a Mutex on the native
+ * side and costs microseconds, so it is safe to call from WebView worker
+ * threads.
+ */
+object ContentFilter {
+    private const val TAG = "ContentFilter"
+    private const val LIBRARY = "contentfilter"
+
+    // Bundled rule list (ABP/EasyList syntax), merged from the library assets.
+    private const val RULES_ASSET = "contentfilter/rules.txt"
+
+    @Volatile private var libraryLoaded = false
+    @Volatile private var initStarted = false
+    @Volatile private var ready = false
+
+    init {
+        try {
+            System.loadLibrary(LIBRARY)
+            libraryLoaded = true
+        } catch (t: Throwable) {
+            Log.e(TAG, "Could not load native library '$LIBRARY'; filtering disabled.", t)
+        }
+    }
+
+    @JvmStatic external fun nativeInit(rules: String): Boolean
+    @JvmStatic external fun nativeIsReady(): Boolean
+    @JvmStatic external fun nativeCheck(url: String, sourceUrl: String, requestType: String): Boolean
+
+    /**
+     * Kick off a one-time background load of the bundled rule list. Safe to call
+     * repeatedly and from any thread; only the first call does work.
+     */
+    fun ensureInitialized(context: Context) {
+        if (!libraryLoaded || initStarted) return
+        synchronized(this) {
+            if (initStarted) return
+            initStarted = true
+        }
+        val appContext = context.applicationContext
+        Thread({
+            try {
+                val rules = appContext.assets.open(RULES_ASSET)
+                    .bufferedReader()
+                    .use { it.readText() }
+                val ok = nativeInit(rules)
+                ready = ok && nativeIsReady()
+                Log.d(TAG, "content filter initialized (ready=$ready)")
+            } catch (t: Throwable) {
+                Log.e(TAG, "content filter initialization failed; filtering disabled.", t)
+            }
+        }, "content-filter-init").start()
+    }
+
+    fun isReady(): Boolean = libraryLoaded && ready
+
+    /**
+     * @return true when the request should be BLOCKED. Fails open.
+     * @param url        full request URL
+     * @param sourceUrl  full top-frame (document) URL, or null/empty if unknown
+     * @param requestType request-type string ("script", "image", "sub_frame",
+     *                    "xmlhttprequest", "font", "media", ...)
+     */
+    fun shouldBlock(url: String, sourceUrl: String?, requestType: String): Boolean {
+        if (!isReady()) return false
+        return try {
+            nativeCheck(url, sourceUrl ?: "", requestType)
+        } catch (t: Throwable) {
+            false
+        }
+    }
+}

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

@@ -2,6 +2,7 @@ package com.reactnativecommunity.webview;
 
 import android.annotation.SuppressLint;
 import android.graphics.Rect;
+import android.net.Uri;
 import android.text.TextUtils;
 import android.view.ActionMode;
 import android.view.Menu;
@@ -14,7 +15,12 @@ import android.webkit.WebChromeClient;
 import android.webkit.WebView;
 import android.webkit.WebViewClient;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.webkit.JavaScriptReplyProxy;
+import androidx.webkit.WebMessageCompat;
+import androidx.webkit.WebViewCompat;
+import androidx.webkit.WebViewFeature;
 
 import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.Arguments;
@@ -38,6 +44,7 @@ import org.json.JSONObject;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 public class RNCWebView extends WebView implements LifecycleEventListener {
     protected @Nullable
@@ -46,7 +53,9 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
     String injectedJSBeforeContentLoaded;
     protected static final String JAVASCRIPT_INTERFACE = "ReactNativeWebView";
     protected @Nullable
-    RNCWebViewBridge bridge;
+    RNCWebViewBridge fallbackBridge;
+    protected @Nullable
+    WebViewCompat.WebMessageListener bridgeListener = null;
 
     /**
      * android.webkit.WebChromeClient fundamentally does not support JS injection into frames other
@@ -68,6 +77,30 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
     protected boolean nestedScrollEnabled = false;
     protected ProgressChangedFilter progressChangedFilter;
 
+    // Content filter: when enabled, RNCWebViewClient.shouldInterceptRequest
+    // filters subresource requests through the native content filter.
+    protected volatile boolean contentBlockerEnabled = false;
+    // Top-frame URL, captured on the UI thread in RNCWebViewClient callbacks and
+    // read from shouldInterceptRequest (which runs off the UI thread). `volatile`
+    // gives the cross-thread visibility; do NOT call getUrl() off the UI thread.
+    protected volatile String lastTopUrl = null;
+
+    public void setContentBlockerEnabled(boolean enabled) {
+        this.contentBlockerEnabled = enabled;
+    }
+
+    public boolean getContentBlockerEnabled() {
+        return this.contentBlockerEnabled;
+    }
+
+    public void setLastTopUrl(String url) {
+        this.lastTopUrl = url;
+    }
+
+    public String getLastTopUrl() {
+        return this.lastTopUrl;
+    }
+
     /**
      * WebView must be created with an context of the current activity
      * <p>
@@ -81,10 +114,6 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
         progressChangedFilter = new ProgressChangedFilter();
     }
 
-    public void setIgnoreErrFailedForThisURL(String url) {
-        mRNCWebViewClient.setIgnoreErrFailedForThisURL(url);
-    }
-
     public void setBasicAuthCredential(RNCBasicAuthCredential credential) {
         mRNCWebViewClient.setBasicAuthCredential(credential);
     }
@@ -246,12 +275,39 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
         return this.messagingEnabled;
     }
 
-    protected RNCWebViewBridge createRNCWebViewBridge(RNCWebView webView) {
-        if (bridge == null) {
-            bridge = new RNCWebViewBridge(webView);
-            addJavascriptInterface(bridge, JAVASCRIPT_INTERFACE);
+    protected void createRNCWebViewBridge(RNCWebView webView) {
+        if (WebViewFeature.isFeatureSupported(WebViewFeature.WEB_MESSAGE_LISTENER)){
+          if (this.bridgeListener == null) {
+            this.bridgeListener = new WebViewCompat.WebMessageListener() {
+              @Override
+              public void onPostMessage(@NonNull WebView view, @NonNull WebMessageCompat message, @NonNull Uri sourceOrigin, boolean isMainFrame, @NonNull JavaScriptReplyProxy replyProxy) {
+                RNCWebView.this.onMessage(message.getData(), sourceOrigin.toString());
+              }
+            };
+            WebViewCompat.addWebMessageListener(
+              webView,
+              JAVASCRIPT_INTERFACE,
+              Set.of("*"),
+              this.bridgeListener
+            );
+          }
+        } else {
+          if (fallbackBridge == null) {
+            fallbackBridge = new RNCWebViewBridge(webView);
+            addJavascriptInterface(fallbackBridge, JAVASCRIPT_INTERFACE);
+          }
         }
-        return bridge;
+        injectJavascriptObject();
+    }
+
+    private void injectJavascriptObject() {
+      if (getSettings().getJavaScriptEnabled()) {
+        String js = "(function(){\n" +
+          "    window." + JAVASCRIPT_INTERFACE + " = window." + JAVASCRIPT_INTERFACE + " || {};\n" +
+          "    window." + JAVASCRIPT_INTERFACE + ".injectedObjectJson = function () { return " + (injectedJavaScriptObject == null ? null : ("`" + injectedJavaScriptObject + "`")) + "; };\n" +
+          "})();";
+        evaluateJavascriptWithFallback(js);
+      }
     }
 
     @SuppressLint("AddJavascriptInterface")
@@ -276,6 +332,7 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
                 injectedJS != null &&
                 !TextUtils.isEmpty(injectedJS)) {
             evaluateJavascriptWithFallback("(function() {\n" + injectedJS + ";\n})();");
+            injectJavascriptObject(); // re-inject the Javascript object in case it has been overwritten.
         }
     }
 
@@ -284,17 +341,18 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
                 injectedJSBeforeContentLoaded != null &&
                 !TextUtils.isEmpty(injectedJSBeforeContentLoaded)) {
             evaluateJavascriptWithFallback("(function() {\n" + injectedJSBeforeContentLoaded + ";\n})();");
+            injectJavascriptObject();  // re-inject the Javascript object in case it has been overwritten.
         }
     }
 
+    protected String injectedJavaScriptObject = null;
+
     public void setInjectedJavaScriptObject(String obj) {
-        if (getSettings().getJavaScriptEnabled()) {
-            RNCWebViewBridge b = createRNCWebViewBridge(this);
-            b.setInjectedObjectJson(obj);
-        }
+      this.injectedJavaScriptObject = obj;
+      injectJavascriptObject();
     }
 
-    public void onMessage(String message) {
+    public void onMessage(String message, String sourceUrl) {
         ThemedReactContext reactContext = getThemedReactContext();
         RNCWebView mWebView = this;
 
@@ -306,7 +364,7 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
                     if (mRNCWebViewClient == null) {
                         return;
                     }
-                    WritableMap data = mRNCWebViewClient.createWebViewEvent(webView, webView.getUrl());
+                    WritableMap data = mRNCWebViewClient.createWebViewEvent(webView, sourceUrl);
                     data.putString("data", message);
 
                     if (mMessagingJSModule != null) {
@@ -408,16 +466,11 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
   protected class RNCWebViewBridge {
         private String TAG = "RNCWebViewBridge";
         RNCWebView mWebView;
-        String injectedObjectJson;
 
         RNCWebViewBridge(RNCWebView c) {
           mWebView = c;
         }
 
-        public void setInjectedObjectJson(String s) {
-            injectedObjectJson = s;
-        }
-
         /**
          * This method is called whenever JavaScript running within the web view calls:
          * - window[JAVASCRIPT_INTERFACE].postMessage
@@ -425,14 +478,12 @@ public class RNCWebView extends WebView implements LifecycleEventListener {
         @JavascriptInterface
         public void postMessage(String message) {
             if (mWebView.getMessagingEnabled()) {
-                mWebView.onMessage(message);
+                // Post to main thread because `mWebView.getUrl()` requires to be executed on main.
+                mWebView.post(() -> mWebView.onMessage(message, mWebView.getUrl()));
             } else {
                 FLog.w(TAG, "ReactNativeWebView.postMessage method was called but messaging is disabled. Pass an onMessage handler to the WebView.");
             }
         }
-
-        @JavascriptInterface
-        public String injectedObjectJson() { return injectedObjectJson; }
     }
 
 

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

@@ -2,6 +2,7 @@ package com.reactnativecommunity.webview;
 
 import android.annotation.TargetApi;
 import android.graphics.Bitmap;
+import android.net.Uri;
 import android.net.http.SslError;
 import android.os.Build;
 import android.os.SystemClock;
@@ -25,6 +26,7 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.UIManagerHelper;
+import com.reactnativecommunity.webview.events.SubResourceErrorEvent;
 import com.reactnativecommunity.webview.events.TopHttpErrorEvent;
 import com.reactnativecommunity.webview.events.TopLoadingErrorEvent;
 import com.reactnativecommunity.webview.events.TopLoadingFinishEvent;
@@ -34,6 +36,9 @@ import com.reactnativecommunity.webview.events.TopShouldStartLoadWithRequestEven
 import android.webkit.CookieManager;
 import android.webkit.CookieSyncManager;
 
+import java.io.ByteArrayInputStream;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 
 public class RNCWebViewClient extends WebViewClient {
@@ -42,13 +47,8 @@ public class RNCWebViewClient extends WebViewClient {
 
     protected boolean mLastLoadFailed = false;
     protected RNCWebView.ProgressChangedFilter progressChangedFilter = null;
-    protected @Nullable String ignoreErrFailedForThisURL = null;
     protected @Nullable RNCBasicAuthCredential basicAuthCredential = null;
 
-    public void setIgnoreErrFailedForThisURL(@Nullable String url) {
-        ignoreErrFailedForThisURL = url;
-    }
-
     public void setBasicAuthCredential(@Nullable RNCBasicAuthCredential credential) {
         basicAuthCredential = credential;
     }
@@ -78,6 +78,10 @@ public class RNCWebViewClient extends WebViewClient {
     public void doUpdateVisitedHistory (WebView webView, String url, boolean isReload) {
       super.doUpdateVisitedHistory(webView, url, isReload);
 
+      // Capture the top-frame URL on the UI thread for off-thread use in
+      // shouldInterceptRequest (also fires on SPA pushState navigations).
+      ((RNCWebView) webView).setLastTopUrl(url);
+
       ((RNCWebView) webView).dispatchEvent(
         webView,
         new TopLoadingStartEvent(
@@ -91,6 +95,7 @@ public class RNCWebViewClient extends WebViewClient {
       mLastLoadFailed = false;
 
       RNCWebView reactWebView = (RNCWebView) webView;
+      reactWebView.setLastTopUrl(url);
       reactWebView.callInjectedJavaScriptBeforeContentLoaded();
     }
 
@@ -150,6 +155,138 @@ public class RNCWebViewClient extends WebViewClient {
         return this.shouldOverrideUrlLoading(view, url);
     }
 
+    // ------------------------------------------------------------------
+    // Content filter: subresource request interception.
+    // shouldInterceptRequest runs OFF the UI thread and is invoked for every
+    // subresource. Matching goes through the native content filter and fails
+    // open (returns super => request proceeds) whenever anything is unclear.
+    // ------------------------------------------------------------------
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    @Override
+    public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
+        if (!(view instanceof RNCWebView) || request == null) {
+            return super.shouldInterceptRequest(view, request);
+        }
+        RNCWebView rncWebView = (RNCWebView) view;
+        if (!rncWebView.getContentBlockerEnabled()) {
+            return super.shouldInterceptRequest(view, request);
+        }
+        // Never block top-frame navigations — only subresources.
+        if (request.isForMainFrame()) {
+            return super.shouldInterceptRequest(view, request);
+        }
+        Uri uri = request.getUrl();
+        if (uri == null) {
+            return super.shouldInterceptRequest(view, request);
+        }
+        String scheme = uri.getScheme();
+        if (scheme == null || !(scheme.equals("http") || scheme.equals("https"))) {
+            return super.shouldInterceptRequest(view, request);
+        }
+
+        String url = uri.toString();
+        String sourceUrl = rncWebView.getLastTopUrl();
+        String requestType = inferRequestType(request);
+
+        try {
+            if (ContentFilter.INSTANCE.shouldBlock(url, sourceUrl, requestType)) {
+                return buildBlockedResponse(requestType);
+            }
+        } catch (Throwable t) {
+            // Fail open on any unexpected error.
+        }
+        return super.shouldInterceptRequest(view, request);
+    }
+
+    private static String headerCaseInsensitive(Map<String, String> headers, String name) {
+        if (headers == null) return null;
+        String v = headers.get(name);
+        if (v != null) return v;
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            if (name.equalsIgnoreCase(e.getKey())) return e.getValue();
+        }
+        return null;
+    }
+
+    // Android does not expose the resource type on WebResourceRequest, so infer
+    // a request-type string from Sec-Fetch-Dest / Accept / extension.
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    private static String inferRequestType(WebResourceRequest request) {
+        Map<String, String> headers = request.getRequestHeaders();
+
+        String dest = headerCaseInsensitive(headers, "Sec-Fetch-Dest");
+        if (dest != null) {
+            switch (dest) {
+                case "script": return "script";
+                case "image": return "image";
+                case "style": return "stylesheet";
+                case "font": return "font";
+                case "iframe":
+                case "frame": return "sub_frame";
+                case "audio":
+                case "video":
+                case "track": return "media";
+                case "document": return "document";
+                default: break;
+            }
+        }
+        String mode = headerCaseInsensitive(headers, "Sec-Fetch-Mode");
+        if ("empty".equals(dest) && ("cors".equals(mode) || "no-cors".equals(mode))) {
+            return "xmlhttprequest";
+        }
+
+        String accept = headerCaseInsensitive(headers, "Accept");
+        if (accept != null) {
+            String a = accept.toLowerCase();
+            if (a.startsWith("text/css")) return "stylesheet";
+            if (a.startsWith("image/")) return "image";
+            if (a.contains("javascript") || a.contains("ecmascript")) return "script";
+            if (a.startsWith("text/html")) return "sub_frame";
+        }
+        String requestedWith = headerCaseInsensitive(headers, "X-Requested-With");
+        if (requestedWith != null && requestedWith.toLowerCase().contains("xmlhttprequest")) {
+            return "xmlhttprequest";
+        }
+
+        String path = request.getUrl().getPath();
+        if (path != null) {
+            String p = path.toLowerCase();
+            if (p.endsWith(".js") || p.endsWith(".mjs")) return "script";
+            if (p.endsWith(".css")) return "stylesheet";
+            if (p.endsWith(".png") || p.endsWith(".jpg") || p.endsWith(".jpeg")
+                || p.endsWith(".webp") || p.endsWith(".gif") || p.endsWith(".svg")
+                || p.endsWith(".ico") || p.endsWith(".bmp")) return "image";
+            if (p.endsWith(".woff") || p.endsWith(".woff2") || p.endsWith(".ttf")
+                || p.endsWith(".otf") || p.endsWith(".eot")) return "font";
+            if (p.endsWith(".mp4") || p.endsWith(".webm") || p.endsWith(".m3u8")
+                || p.endsWith(".ts") || p.endsWith(".mp3") || p.endsWith(".m4a")
+                || p.endsWith(".aac") || p.endsWith(".ogg")) return "media";
+        }
+        return "other";
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    private WebResourceResponse buildBlockedResponse(String requestType) {
+        String mime;
+        switch (requestType) {
+            case "script": mime = "application/javascript"; break;
+            case "stylesheet": mime = "text/css"; break;
+            case "image": mime = "image/png"; break;
+            case "font": mime = "font/woff2"; break;
+            case "media": mime = "video/mp4"; break;
+            default: mime = "text/plain"; break;
+        }
+        WebResourceResponse response =
+            new WebResourceResponse(mime, "utf-8", new ByteArrayInputStream(new byte[0]));
+        // Set an explicit status so the response headers below are honored
+        // (a status-0 response can have its headers ignored on some WebViews).
+        response.setStatusCodeAndReasonPhrase(200, "OK");
+        Map<String, String> headers = new HashMap<>();
+        headers.put("Access-Control-Allow-Origin", "*");
+        response.setResponseHeaders(headers);
+        return response;
+    }
+
     @Override
     public void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm) {
         if (basicAuthCredential != null) {
@@ -173,12 +310,6 @@ public class RNCWebViewClient extends WebViewClient {
         // Undesired behavior: Return value of WebView.getUrl() may be the current URL instead of the failing URL.
         handler.cancel();
 
-        if (!topWindowUrl.equalsIgnoreCase(failingUrl)) {
-            // If error is not due to top-level navigation, then do not call onReceivedError()
-            Log.w(TAG, "Resource blocked from loading due to SSL error. Blocked URL: "+failingUrl);
-            return;
-        }
-
         int code = error.getPrimaryError();
         String description = "";
         String descriptionPrefix = "SSL error: ";
@@ -210,6 +341,18 @@ public class RNCWebViewClient extends WebViewClient {
 
         description = descriptionPrefix + description;
 
+      if (!topWindowUrl.equalsIgnoreCase(failingUrl)) {
+        // If error is not due to top-level navigation, then do not call onReceivedError()
+        Log.w(TAG, "Resource blocked from loading due to SSL error. Blocked URL: "+failingUrl);
+        this.onReceivedSubResourceSslError(
+          webView,
+          code,
+          description,
+          failingUrl
+        );
+        return;
+      }
+
         this.onReceivedError(
                 webView,
                 code,
@@ -218,6 +361,20 @@ public class RNCWebViewClient extends WebViewClient {
         );
     }
 
+    public void onReceivedSubResourceSslError(
+      WebView webView,
+      int errorCode,
+      String description,
+      String failingUrl) {
+
+      WritableMap eventData = createWebViewEvent(webView, failingUrl);
+      eventData.putDouble("code", errorCode);
+      eventData.putString("description", description);
+
+      int reactTag = RNCWebViewWrapper.getReactTagFromWebView(webView);
+      UIManagerHelper.getEventDispatcherForReactTag((ReactContext) webView.getContext(), reactTag).dispatchEvent(new SubResourceErrorEvent(reactTag, eventData));
+    }
+
     @Override
     public void onReceivedError(
             WebView webView,
@@ -225,20 +382,6 @@ public class RNCWebViewClient extends WebViewClient {
             String description,
             String failingUrl) {
 
-        if (ignoreErrFailedForThisURL != null
-                && failingUrl.equals(ignoreErrFailedForThisURL)
-                && errorCode == -1
-                && description.equals("net::ERR_FAILED")) {
-
-            // This is a workaround for a bug in the WebView.
-            // See these chromium issues for more context:
-            // https://bugs.chromium.org/p/chromium/issues/detail?id=1023678
-            // https://bugs.chromium.org/p/chromium/issues/detail?id=1050635
-            // This entire commit should be reverted once this bug is resolved in chromium.
-            setIgnoreErrFailedForThisURL(null);
-            return;
-        }
-
         super.onReceivedError(webView, errorCode, description, failingUrl);
         mLastLoadFailed = true;
 

package/android/src/main/java/com/reactnativecommunity/webview/RNCWebViewManagerImpl.kt

@@ -92,7 +92,6 @@ class RNCWebViewManagerImpl(private val newArch: Boolean = false) {
             WebView.setWebContentsDebuggingEnabled(true)
         }
         webView.setDownloadListener(DownloadListener { url, userAgent, contentDisposition, mimetype, contentLength ->
-            webView.setIgnoreErrFailedForThisURL(url)
             val module = webView.reactApplicationContext.getNativeModule(RNCWebViewModule::class.java) ?: return@DownloadListener
             val request: DownloadManager.Request = try {
                 DownloadManager.Request(Uri.parse(url))
@@ -341,11 +340,9 @@ class RNCWebViewManagerImpl(private val newArch: Boolean = false) {
         }
         "injectJavaScript" -> webView.evaluateJavascriptWithFallback(args.getString(0))
         "loadUrl" -> {
-          if (args == null) {
-            throw RuntimeException("Arguments for loading an url are null!")
-          }
+          val url = args?.getString(0) ?: throw RuntimeException("Arguments for loading an url are null!")
           webView.progressChangedFilter.setWaitingForCommandLoadUrl(false)
-            args.getString(0)?.let { webView.loadUrl(it) }
+          webView.loadUrl(url)
         }
         "requestFocus" -> webView.requestFocus()
         "clearFormData" -> webView.clearFormData()
@@ -541,7 +538,11 @@ class RNCWebViewManagerImpl(private val newArch: Boolean = false) {
     }
     
     fun setContentBlockerEnabled(viewWrapper: RNCWebViewWrapper, value: Boolean) {
-        //
+        viewWrapper.webView.setContentBlockerEnabled(value)
+        if (value) {
+            // Lazily warm up the native engine only when filtering is actually used.
+            ContentFilter.ensureInitialized(viewWrapper.webView.context)
+        }
     }
 
     fun setHasOnScroll(viewWrapper: RNCWebViewWrapper, value: Boolean) {
@@ -721,4 +722,11 @@ class RNCWebViewManagerImpl(private val newArch: Boolean = false) {
     fun setWebviewDebuggingEnabled(viewWrapper: RNCWebViewWrapper, enabled: Boolean) {
         RNCWebView.setWebContentsDebuggingEnabled(enabled)
     }
-}
+
+    fun setPaymentRequestEnabled(viewWrapper: RNCWebViewWrapper, enabled: Boolean) {
+        val view = viewWrapper.webView
+        if (WebViewFeature.isFeatureSupported(WebViewFeature.PAYMENT_REQUEST)) {
+            WebSettingsCompat.setPaymentRequestEnabled(view.settings, enabled)
+        }
+    }
+}

package/android/src/main/java/com/reactnativecommunity/webview/events/SubResourceErrorEvent.kt

@@ -0,0 +1,25 @@
+package com.reactnativecommunity.webview.events
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+/**
+ * Event emitted when there is an error in loading a subresource
+ */
+class SubResourceErrorEvent(viewId: Int, private val mEventData: WritableMap) :
+  Event<SubResourceErrorEvent>(viewId) {
+  companion object {
+    const val EVENT_NAME = "topLoadingSubResourceError"
+  }
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun canCoalesce(): Boolean = false
+
+  override fun getCoalescingKey(): Short = 0
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) =
+    rctEventEmitter.receiveEvent(viewTag, eventName, mEventData)
+
+}

package/android/src/newarch/com/reactnativecommunity/webview/RNCWebViewManager.java

@@ -15,6 +15,7 @@ import com.facebook.react.viewmanagers.RNCWebViewManagerDelegate;
 import com.facebook.react.viewmanagers.RNCWebViewManagerInterface;
 import com.facebook.react.views.scroll.ScrollEventType;
 import com.reactnativecommunity.webview.events.TopCustomMenuSelectionEvent;
+import com.reactnativecommunity.webview.events.SubResourceErrorEvent;
 import com.reactnativecommunity.webview.events.TopHttpErrorEvent;
 import com.reactnativecommunity.webview.events.TopLoadingErrorEvent;
 import com.reactnativecommunity.webview.events.TopLoadingFinishEvent;
@@ -232,7 +233,7 @@ public class RNCWebViewManager extends ViewGroupManager<RNCWebViewWrapper>
     }
 
     @Override
-    @ReactProp(name = "suppressMenuItems ")
+    @ReactProp(name = "suppressMenuItems")
     public void setSuppressMenuItems(RNCWebViewWrapper view, @Nullable ReadableArray items) {}
 
     @Override
@@ -337,6 +338,12 @@ public class RNCWebViewManager extends ViewGroupManager<RNCWebViewWrapper>
         mRNCWebViewManagerImpl.setWebviewDebuggingEnabled(view, value);
     }
 
+    @Override
+    @ReactProp(name = "paymentRequestEnabled")
+    public void setPaymentRequestEnabled(RNCWebViewWrapper view, boolean value) {
+        mRNCWebViewManagerImpl.setPaymentRequestEnabled(view, value);
+    }
+
     /* iOS PROPS - no implemented here */
     @Override
     public void setAllowingReadAccessToURL(RNCWebViewWrapper view, @Nullable String value) {}
@@ -401,6 +408,9 @@ public class RNCWebViewManager extends ViewGroupManager<RNCWebViewWrapper>
     @Override
     public void setRefreshControlLightMode(RNCWebViewWrapper view, boolean value) {}
 
+    @Override
+    public void setIndicatorStyle(RNCWebViewWrapper view, @Nullable String value) {}
+
     @Override
     public void setScrollEnabled(RNCWebViewWrapper view, boolean value) {}
 
@@ -521,6 +531,7 @@ public class RNCWebViewManager extends ViewGroupManager<RNCWebViewWrapper>
         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(SubResourceErrorEvent.EVENT_NAME, MapBuilder.of("registrationName", "onLoadingSubResourceError"));
         export.put(TopMessageEvent.EVENT_NAME, MapBuilder.of("registrationName", "onMessage"));
         // !Default events but adding them here explicitly for clarity