@capgo/capacitor-inappbrowser 8.21.2 → 8.22.1

package/README.md

@@ -5,7 +5,7 @@ Open web content inside your Capacitor app with a full-featured in-app browser:
 <a href="https://capgo.app/?ref=plugin_inappbrowser"><img src="https://capgo.app/readme-banner.svg?repo=Cap-go/capacitor-inappbrowser" alt="Capgo - Instant updates for Capacitor" /></a>
 
 <div align="center">
-  <p><b>Capgo</b>: open-source live updates for Ionic and Capacitor apps. Ship OTA fixes and features instantly, without waiting for app store review.</p>
+  <p><b>Capgo</b>: push fixes to your Capacitor users in minutes, build signed iOS and Android apps without a Mac, and roll back in one click.</p>
   <h2><a href="https://capgo.app/register/?ref=plugin_inappbrowser">➡️ Get started for free</a></h2>
   <p>14-day unlimited free trial. No credit card required</p>
   <p><a href="https://capgo.app/consulting/?ref=plugin_inappbrowser">Missing a feature? We'll build the plugin for you 💪</a></p>
@@ -1714,6 +1714,7 @@ See the README section "openSecureWindow (OAuth)" for full setup examples.
 | **`backgroundColor`**                  | <code><a href="#backgroundcolor">BackgroundColor</a></code>                                                                                                            | Background color of the browser                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | <code>BackgroundColor.BLACK</code>                            | 0.1.0  |
 | **`activeNativeNavigationForWebview`** | <code>boolean</code>                                                                                                                                                   | If true, enables native navigation gestures within the webview. - Android: Native back button navigates within webview history - iOS: Enables swipe left/right gestures for back/forward navigation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | <code>false (Android), true (iOS - enabled by default)</code> |        |
 | **`enableReloadGesture`**              | <code>boolean</code>                                                                                                                                                   | Enable pull-to-refresh (overscroll from top) to reload the current page. - iOS: Uses UIRefreshControl on the WebView scroll view (reload commits on finger release) - Android: Uses SwipeRefreshLayout around the WebView On iOS, this requires overscroll bounce. If `disableOverscroll` is `true`, the reload gesture will not work.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | <code>false</code>                                            | 8.10.8 |
+| **`allowWebViewFullscreen`**           | <code>boolean</code>                                                                                                                                                   | Allow pages to enter HTML5 fullscreen (e.g. `requestFullscreen()` or a video player's fullscreen button). When `false`, fullscreen requests are rejected and the toolbar stays visible, so the user can always close the browser. Android only. On iOS, element fullscreen is not enabled by the plugin, so this option has no effect.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | <code>true</code>                                             | 8.22.0 |
 | **`disableGoBackOnNativeApplication`** | <code>boolean</code>                                                                                                                                                   | Disable the possibility to go back on native application, useful to force user to stay on the webview, Android only                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | <code>false</code>                                            |        |
 | **`isPresentAfterPageLoad`**           | <code>boolean</code>                                                                                                                                                   | Open url in a new window fullscreen isPresentAfterPageLoad: if true, the browser will be presented after the page is loaded, if false, the browser will be presented immediately. Promise timing: on Android, `openWebView()` resolves with the webview id when the webview is ready to be controlled (immediately for hidden/immediate presentation, after the first page load when `isPresentAfterPageLoad` is `true`). On iOS, the promise resolves with the id as soon as the native webview is created, even if presentation is deferred.                                                                                                                                                                                                                                                                                                                                                                         | <code>false</code>                                            | 0.1.0  |
 | **`preferredContentMode`**             | <code><a href="#preferredcontentmode">PreferredContentMode</a></code>                                                                                                  | Web content rendering mode for the managed WKWebView. Controls whether pages load with mobile or desktop layout on iPad. Matches Capacitor's `ios.preferredContentMode` behavior. Resolution order when opening a webview: 1. This per-open value 2. Plugin config `plugins.CapgoInAppBrowser.preferredContentMode` 3. Legacy plugin config `plugins.InAppBrowser.preferredContentMode` 4. Capacitor config `ios.preferredContentMode` When unset at all levels, the system default applies (device-recommended). **iOS only** — ignored on Android and Web.                                                                                                                                                                                                                                                                                                                                                           |                                                               | 8.18.0 |

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/CapgoInAppBrowserPlugin.java

@@ -1286,6 +1286,7 @@ public class CapgoInAppBrowserPlugin extends Plugin implements WebViewDialog.Per
 
         options.setActiveNativeNavigationForWebview(Boolean.TRUE.equals(call.getBoolean("activeNativeNavigationForWebview", false)));
         options.setEnableReloadGesture(Boolean.TRUE.equals(call.getBoolean("enableReloadGesture", false)));
+        options.setAllowWebViewFullscreen(!Boolean.FALSE.equals(call.getBoolean("allowWebViewFullscreen", true)));
         options.setDisableGoBackOnNativeApplication(Boolean.TRUE.equals(call.getBoolean("disableGoBackOnNativeApplication", false)));
         options.setPresentAfterPageLoad(Boolean.TRUE.equals(call.getBoolean("isPresentAfterPageLoad", false)));
         options.setPluginCall(call);

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/FileInputCaptureChooserSupport.java

@@ -0,0 +1,150 @@
+package ee.forgr.capacitor_inappbrowser;
+
+/**
+ * Decides whether a file chooser request should use the direct camera capture path and
+ * builds JavaScript used to detect {@code capture} on file inputs (including shadow DOM).
+ */
+final class FileInputCaptureChooserSupport {
+
+    private FileInputCaptureChooserSupport() {}
+
+    static boolean usesCameraCapturePath(boolean imageOnlyAcceptTypes, boolean captureEnabled) {
+        return imageOnlyAcceptTypes && captureEnabled;
+    }
+
+    /**
+     * Document-level click hook installed at document start (and on navigation fallback).
+     */
+    static String createFileInputCaptureHookScript() {
+        return (
+            """
+            (function() {
+              if (window.__capgoFileInputCaptureHook) {
+                return;
+              }
+              window.__capgoFileInputCaptureHook = true;
+              window.__capgoLastFileCapture = null;
+              """ +
+            captureDetectionHelpersJs() +
+            """
+              var notifyCapture = function(value) {
+                var captureValue = value || 'environment';
+                window.__capgoLastFileCapture = captureValue;
+                try {
+                  var bridge = window.AndroidInterface || window.mobileApp;
+                  if (bridge && bridge.setFileInputCapture) {
+                    bridge.setFileInputCapture(captureValue);
+                  }
+                } catch (err) {}
+              };
+              var register = function(doc) {
+                if (!doc || doc.__capgoFileInputCaptureRegistered) {
+                  return;
+                }
+                doc.__capgoFileInputCaptureRegistered = true;
+                doc.addEventListener('click', function(e) {
+                  var captureValue = capgoFindCaptureFromClickEvent(e);
+                  if (captureValue) {
+                    notifyCapture(captureValue);
+                  }
+                }, true);
+              };
+              register(document);
+              window.addEventListener('load', function(e) {
+                var el = e.target;
+                try {
+                  if (el && el.tagName === 'IFRAME' && el.contentDocument) {
+                    register(el.contentDocument);
+                  }
+                } catch (err) {}
+              }, true);
+            })();
+            """
+        );
+    }
+
+    /**
+     * Runs when the native chooser opens, after {@code consumeLastFileInputCaptureValue()}.
+     */
+    static String createChooserFallbackCaptureResolutionScript() {
+        return (
+            """
+            (function() {
+              try {
+                """ +
+            captureDetectionHelpersJs() +
+            """
+                var cached = window.__capgoLastFileCapture;
+                window.__capgoLastFileCapture = null;
+                if (cached) {
+                  return cached;
+                }
+                var fromActive = capgoFindCaptureFromActiveElementChain();
+                if (fromActive) {
+                  return fromActive;
+                }
+                var inputs = document.querySelectorAll('input[type="file"][capture]');
+                if (inputs && inputs.length === 1) {
+                  return inputs[0].getAttribute('capture') || 'environment';
+                }
+                return 'environment';
+              } catch (e) {
+                return 'environment';
+              }
+            })();
+            """
+        );
+    }
+
+    private static String captureDetectionHelpersJs() {
+        return """
+          var capgoNormalizeCapture = function(value) {
+            return value || 'environment';
+          };
+          var capgoIsCaptureFileInput = function(node) {
+            return node && node.tagName === 'INPUT' && node.type === 'file' && node.hasAttribute('capture');
+          };
+          var capgoFindCaptureFromClickEvent = function(e) {
+            if (!e) {
+              return null;
+            }
+            var path = e.composedPath ? e.composedPath() : null;
+            if (path && path.length) {
+              for (var i = 0; i < path.length; i++) {
+                var node = path[i];
+                if (capgoIsCaptureFileInput(node)) {
+                  return capgoNormalizeCapture(node.getAttribute('capture'));
+                }
+              }
+            }
+            if (capgoIsCaptureFileInput(e.target)) {
+              return capgoNormalizeCapture(e.target.getAttribute('capture'));
+            }
+            return null;
+          };
+          var capgoFindCaptureFromActiveElementChain = function() {
+            var el = document.activeElement;
+            var depth = 0;
+            while (el && depth < 32) {
+              if (capgoIsCaptureFileInput(el)) {
+                return capgoNormalizeCapture(el.getAttribute('capture'));
+              }
+              if (el.shadowRoot) {
+                var inner = el.shadowRoot.activeElement;
+                if (inner) {
+                  el = inner;
+                  depth++;
+                  continue;
+                }
+                var shadowInput = el.shadowRoot.querySelector('input[type="file"][capture]');
+                if (shadowInput) {
+                  return capgoNormalizeCapture(shadowInput.getAttribute('capture'));
+                }
+              }
+              break;
+            }
+            return null;
+          };
+        """;
+    }
+}

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/Options.java

@@ -164,6 +164,7 @@ public class Options {
     private boolean disableGoBackOnNativeApplication;
     private boolean activeNativeNavigationForWebview;
     private boolean enableReloadGesture = false;
+    private boolean allowWebViewFullscreen = true;
     private boolean isPresentAfterPageLoad;
     private WebViewCallbacks callbacks;
     private PluginCall pluginCall;
@@ -649,6 +650,14 @@ public class Options {
         this.enableReloadGesture = enableReloadGesture;
     }
 
+    public boolean getAllowWebViewFullscreen() {
+        return allowWebViewFullscreen;
+    }
+
+    public void setAllowWebViewFullscreen(boolean allowWebViewFullscreen) {
+        this.allowWebViewFullscreen = allowWebViewFullscreen;
+    }
+
     public boolean getDisableGoBackOnNativeApplication() {
         return disableGoBackOnNativeApplication;
     }
@@ -879,6 +888,7 @@ public class Options {
         copy.setDisableGoBackOnNativeApplication(disableGoBackOnNativeApplication);
         copy.setActiveNativeNavigationForWebview(activeNativeNavigationForWebview);
         copy.setEnableReloadGesture(enableReloadGesture);
+        copy.setAllowWebViewFullscreen(allowWebViewFullscreen);
         copy.setPresentAfterPageLoad(false);
         copy.setVisibleTitle(VisibleTitle);
         copy.setToolbarColor(ToolbarColor);

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/WebViewCustomFullscreenSupport.java

@@ -22,6 +22,10 @@ final class WebViewCustomFullscreenSupport {
         return isActive;
     }
 
+    static boolean shouldRejectShow(boolean allowWebViewFullscreen, boolean isActive) {
+        return !allowWebViewFullscreen || shouldRejectDuplicateShow(isActive);
+    }
+
     static boolean shouldConsumeBackPress(boolean isActive) {
         return isActive;
     }

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/WebViewDialog.java

@@ -591,6 +591,9 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
     // Temporary URI for storing camera capture
     public Uri tempCameraUri;
 
+    // Last file input capture attribute reported from any frame (including cross-origin iframes).
+    private volatile String lastFileInputCaptureValue;
+
     public interface PermissionHandler {
         void handleCameraPermissionRequest(PermissionRequest request);
 
@@ -1061,6 +1064,11 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
             handleJavaScriptPostMessage(message);
         }
 
+        @JavascriptInterface
+        public void setFileInputCapture(String captureValue) {
+            storeLastFileInputCaptureValue(captureValue == null || captureValue.isEmpty() ? "environment" : captureValue);
+        }
+
         @JavascriptInterface
         public void close() {
             try {
@@ -2505,6 +2513,8 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
 
         _webView.setWebChromeClient(
             new WebChromeClient() {
+                private Bitmap transparentVideoPoster;
+
                 @Override
                 public boolean onConsoleMessage(ConsoleMessage consoleMessage) {
                     if (consoleMessage != null && _options != null && _options.getCaptureConsoleLogs() && _options.getCallbacks() != null) {
@@ -2521,6 +2531,15 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
                     return super.onConsoleMessage(consoleMessage);
                 }
 
+                // Android WebView otherwise paints a stretched grey play icon on <video> without poster or frames; Chrome paints nothing.
+                @Override
+                public Bitmap getDefaultVideoPoster() {
+                    if (transparentVideoPoster == null) {
+                        transparentVideoPoster = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
+                    }
+                    return transparentVideoPoster;
+                }
+
                 // Enable HTML5/iframe fullscreen (e.g. embedded YouTube player fullscreen button).
                 @Override
                 public void onShowCustomView(View view, WebChromeClient.CustomViewCallback callback) {
@@ -2562,140 +2581,36 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
                     beginFileChooserRequest(filePathCallback, acceptTypes, isMultiple);
                     final FileChooserRequestSupport.FileChooserRequest request = activeFileChooserRequest;
 
-                    // Direct check for capture attribute in URL (fallback method)
-                    boolean isCaptureInUrl;
-                    String captureMode;
-                    String currentUrl = getUrl();
+                    final boolean imageOnlyAcceptTypes = FileChooserAcceptSupport.isImageOnlyAcceptTypes(acceptTypes);
+                    final boolean captureEnabled = fileChooserParams.isCaptureEnabled();
+                    final String nativeCaptureForRequest = consumeLastFileInputCaptureValue();
 
-                    // Look for capture in URL parameters - sometimes the attribute shows up in URL
-                    if (currentUrl != null && currentUrl.contains("capture=")) {
-                        isCaptureInUrl = true;
-                        captureMode = currentUrl.contains("capture=user") ? "user" : "environment";
-                        Log.d("InAppBrowser", "Found capture in URL: " + captureMode);
-                    } else {
-                        captureMode = null;
-                        isCaptureInUrl = false;
+                    if (!FileInputCaptureChooserSupport.usesCameraCapturePath(imageOnlyAcceptTypes, captureEnabled)) {
+                        clearFileInputCapturePageState(webView);
+                        openFileChooser(request);
+                        return true;
                     }
 
-                    // For image-only inputs, try to detect capture attribute using JavaScript.
-                    // Mixed accept lists (e.g. "image/*,application/pdf") must skip the camera
-                    // path entirely — the camera can only produce images.
-                    if (FileChooserAcceptSupport.isImageOnlyAcceptTypes(acceptTypes)) {
-                        // Check if HTML content contains capture attribute on file inputs (synchronous check)
-                        webView.evaluateJavascript(
-                            "document.querySelector('input[type=\"file\"][capture]') !== null",
-                            (hasCaptureValue) -> {
-                                Log.d("InAppBrowser", "Quick capture check: " + hasCaptureValue);
-                                if (Boolean.parseBoolean(hasCaptureValue.replace("\"", ""))) {
-                                    Log.d("InAppBrowser", "Found capture attribute in quick check");
-                                }
-                            }
-                        );
-
-                        // Fixed JavaScript with proper error handling
-                        String js = """
-                            (function() {
-                              try {
-                                var captureAttr = null;
-                                // Check active element first
-                                if (document.activeElement &&
-                                    document.activeElement.tagName === 'INPUT' &&
-                                    document.activeElement.type === 'file') {
-                                  if (document.activeElement.hasAttribute('capture')) {
-                                    captureAttr = document.activeElement.getAttribute('capture') || 'environment';
-                                    return captureAttr;
-                                  }
-                                }
-                                // Try to find any input with capture attribute
-                                var inputs = document.querySelectorAll('input[type="file"][capture]');
-                                if (inputs && inputs.length > 0) {
-                                  captureAttr = inputs[0].getAttribute('capture') || 'environment';
-                                  return captureAttr;
-                                }
-                                // Try to extract from HTML attributes
-                                var allInputs = document.getElementsByTagName('input');
-                                for (var i = 0; i < allInputs.length; i++) {
-                                  var input = allInputs[i];
-                                  if (input.type === 'file') {
-                                    if (input.hasAttribute('capture')) {
-                                      captureAttr = input.getAttribute('capture') || 'environment';
-                                      return captureAttr;
-                                    }
-                                    // Look for the accept attribute containing image/* as this might be a camera input
-                                    var acceptAttr = input.getAttribute('accept');
-                                    if (acceptAttr && acceptAttr.indexOf('image/*') >= 0) {
-                                      console.log('Found input with image/* accept');
-                                    }
-                                  }
-                                }
-                                return '';
-                              } catch(e) {
-                                console.error('Capture detection error:', e);
-                                return '';
-                              }
-                            })();
-                            """;
-
-                        webView.evaluateJavascript(js, (value) -> {
-                            if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
-                                return;
-                            }
-
-                            Log.d("InAppBrowser", "Capture attribute JS result: " + value);
-
-                            // If we already found capture in URL, use that directly
-                            if (isCaptureInUrl) {
-                                Log.d("InAppBrowser", "Using capture from URL: " + captureMode);
-                                launchCamera(captureMode.equals("user"), request);
-                                return;
-                            }
-
-                            // Process JavaScript result
-                            if (value != null && value.length() > 2) {
-                                // Clean up the value (remove quotes)
-                                String captureValue = value.replace("\"", "");
-                                Log.d("InAppBrowser", "Found capture attribute: " + captureValue);
-
-                                if (!captureValue.isEmpty()) {
-                                    activity.runOnUiThread(() -> launchCamera(captureValue.equals("user"), request));
-                                    return;
-                                }
-                            }
-
-                            // Look for hints in the web page source
-                            Log.d("InAppBrowser", "Looking for camera hints in page content");
-                            webView.evaluateJavascript("(function() { return document.documentElement.innerHTML; })()", (htmlSource) -> {
-                                if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
-                                    return;
-                                }
-
-                                if (htmlSource != null && htmlSource.length() > 10) {
-                                    boolean hasCameraOrSelfieKeyword =
-                                        htmlSource.contains("capture=") || htmlSource.contains("camera") || htmlSource.contains("selfie");
-
-                                    Log.d("InAppBrowser", "Page contains camera keywords: " + hasCameraOrSelfieKeyword);
-
-                                    if (
-                                        hasCameraOrSelfieKeyword &&
-                                        currentUrl != null &&
-                                        (currentUrl.contains("selfie") || currentUrl.contains("camera") || currentUrl.contains("photo"))
-                                    ) {
-                                        Log.d("InAppBrowser", "URL suggests camera usage, launching camera");
-                                        activity.runOnUiThread(() -> launchCamera(currentUrl.contains("selfie"), request));
-                                        return;
-                                    }
-                                }
-
-                                // If all detection methods fail, fall back to regular file picker
-                                Log.d("InAppBrowser", "No capture attribute detected, using file picker");
-                                openFileChooser(request);
-                            });
-                        });
+                    // For image-only inputs with capture enabled, launch the camera when possible.
+                    // Mixed accept lists (e.g. "image/*,application/pdf") use the regular picker above.
+                    if (nativeCaptureForRequest != null && !nativeCaptureForRequest.isEmpty()) {
+                        if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                            return true;
+                        }
+                        boolean useFrontCameraFromNative = nativeCaptureForRequest.equalsIgnoreCase("user");
+                        activity.runOnUiThread(() -> launchCamera(useFrontCameraFromNative, request));
                         return true;
                     }
 
-                    // For non-image types, use regular file picker
-                    openFileChooser(request);
+                    String js = FileInputCaptureChooserSupport.createChooserFallbackCaptureResolutionScript();
+
+                    webView.evaluateJavascript(js, (value) -> {
+                        if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                            return;
+                        }
+                        boolean useFrontCamera = value != null && value.replace("\"", "").equalsIgnoreCase("user");
+                        activity.runOnUiThread(() -> launchCamera(useFrontCamera, request));
+                    });
                     return true;
                 }
 
@@ -3284,7 +3199,8 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
 
     // Shows a native fullscreen view requested via the HTML5 Fullscreen API (e.g. embedded YouTube).
     private void showCustomFullscreenView(View view, WebChromeClient.CustomViewCallback callback) {
-        if (WebViewCustomFullscreenSupport.shouldRejectDuplicateShow(customFullscreenView != null)) {
+        boolean allowWebViewFullscreen = _options == null || _options.getAllowWebViewFullscreen();
+        if (WebViewCustomFullscreenSupport.shouldRejectShow(allowWebViewFullscreen, customFullscreenView != null)) {
             callback.onCustomViewHidden();
             return;
         }
@@ -3571,6 +3487,10 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
             configureBlankToolbarLayout();
         }
 
+        if (toolbarView != null && toolbarView.getParent() instanceof com.google.android.material.appbar.AppBarLayout appBarLayout) {
+            removeAppBarShadow(appBarLayout);
+        }
+
         // Special handling for Android 15+
         if (isAndroid15Plus && !isBlankToolbar) {
             refreshEdgeToEdgeChrome();
@@ -3828,6 +3748,13 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
         statusBarColorView.requestLayout();
     }
 
+    // AppBarLayout re-applies its elevation through the StateListAnimator, so clearing the elevation alone is not enough.
+    private static void removeAppBarShadow(com.google.android.material.appbar.AppBarLayout appBarLayout) {
+        appBarLayout.setElevation(0);
+        appBarLayout.setStateListAnimator(null);
+        appBarLayout.setOutlineProvider(null);
+    }
+
     private void refreshEdgeToEdgeChrome() {
         if (_webView == null || _options == null) {
             return;
@@ -3840,9 +3767,7 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
             return;
         }
 
-        appBarLayout.setElevation(0);
-        appBarLayout.setStateListAnimator(null);
-        appBarLayout.setOutlineProvider(null);
+        removeAppBarShadow(appBarLayout);
 
         final int finalBgColor = resolveWindowBackgroundColor();
         _webView.post(() -> {
@@ -4392,6 +4317,23 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
         _webView.post(() -> callback.onError(message));
     }
 
+    private synchronized void storeLastFileInputCaptureValue(String captureValue) {
+        lastFileInputCaptureValue = captureValue;
+    }
+
+    private synchronized String consumeLastFileInputCaptureValue() {
+        String value = lastFileInputCaptureValue;
+        lastFileInputCaptureValue = null;
+        return value;
+    }
+
+    private void clearFileInputCapturePageState(WebView webView) {
+        if (webView == null) {
+            return;
+        }
+        webView.evaluateJavascript("(function(){ window.__capgoLastFileCapture = null; })();", null);
+    }
+
     private void injectJavaScriptInterface() {
         if (_webView == null) {
             Log.w("InAppBrowser", "Cannot inject JavaScript interface - WebView is null");
@@ -4405,6 +4347,7 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
                 if (_webView != null) {
                     try {
                         _webView.evaluateJavascript(script, null);
+                        injectFileInputCaptureHookScript();
                         injectBlankTargetInCurrentWebViewScript();
                     } catch (Exception e) {
                         Log.e("InAppBrowser", "Error injecting JavaScript interface: " + e.getMessage());
@@ -4416,6 +4359,17 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
         }
     }
 
+    private void injectFileInputCaptureHookScript() {
+        if (_webView == null) {
+            return;
+        }
+        _webView.evaluateJavascript(createFileInputCaptureHookScript(), null);
+    }
+
+    private String createFileInputCaptureHookScript() {
+        return FileInputCaptureChooserSupport.createFileInputCaptureHookScript();
+    }
+
     private void injectDocumentStartJavaScriptInterface() {
         if (_webView == null) {
             Log.w("InAppBrowser", "Cannot inject document-start JavaScript interface - WebView is null");
@@ -4428,6 +4382,7 @@ public class WebViewDialog extends ComponentDialog implements ProxyResponseRouti
 
         try {
             injectDocumentStartPostMessageBridge();
+            WebViewCompat.addDocumentStartJavaScript(_webView, createFileInputCaptureHookScript(), Collections.singleton("*"));
             WebViewCompat.addDocumentStartJavaScript(_webView, createMobileAppBridgeScript(), Collections.singleton("*"));
             // Honor preShowScriptInjectionTime: "documentStart" (matches iOS WKUserScript
             // .atDocumentStart). Runs before page scripts and persists across navigations,

package/dist/docs.json

@@ -1958,6 +1958,26 @@
           "complexTypes": [],
           "type": "boolean | undefined"
         },
+        {
+          "name": "allowWebViewFullscreen",
+          "tags": [
+            {
+              "text": "8.22.0",
+              "name": "since"
+            },
+            {
+              "text": "true",
+              "name": "default"
+            },
+            {
+              "text": "allowWebViewFullscreen: false",
+              "name": "example"
+            }
+          ],
+          "docs": "Allow pages to enter HTML5 fullscreen (e.g. `requestFullscreen()` or a video player's fullscreen button).\nWhen `false`, fullscreen requests are rejected and the toolbar stays visible, so the user can always close the browser.\n\nAndroid only. On iOS, element fullscreen is not enabled by the plugin, so this option has no effect.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
         {
           "name": "disableGoBackOnNativeApplication",
           "tags": [

package/dist/esm/definitions.d.ts

@@ -996,6 +996,18 @@ export interface OpenWebViewOptions {
      * enableReloadGesture: true
      */
     enableReloadGesture?: boolean;
+    /**
+     * Allow pages to enter HTML5 fullscreen (e.g. `requestFullscreen()` or a video player's fullscreen button).
+     * When `false`, fullscreen requests are rejected and the toolbar stays visible, so the user can always close the browser.
+     *
+     * Android only. On iOS, element fullscreen is not enabled by the plugin, so this option has no effect.
+     *
+     * @since 8.22.0
+     * @default true
+     * @example
+     * allowWebViewFullscreen: false
+     */
+    allowWebViewFullscreen?: boolean;
     /**
      * Disable the possibility to go back on native application,
      * useful to force user to stay on the webview, Android only