@capgo/capacitor-inappbrowser 8.14.3 → 8.15.1

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

@@ -81,6 +81,7 @@ import androidx.core.view.WindowInsetsControllerCompat;
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
 import androidx.webkit.WebMessageCompat;
 import androidx.webkit.WebSettingsCompat;
+import androidx.webkit.WebViewAssetLoader;
 import androidx.webkit.WebViewCompat;
 import androidx.webkit.WebViewFeature;
 import com.caverock.androidsvg.SVG;
@@ -344,6 +345,8 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
     private String instanceId = "";
     private final Map<String, ProxiedRequest> proxiedRequestsHashmap = new ConcurrentHashMap<>();
     private ProxyBridge proxyBridge;
+    private volatile WebViewAssetLoader bundledAssetLoader;
+    private final Object bundledAssetLoaderLock = new Object();
     private String proxyBridgeScript;
     private String proxyAccessToken;
     private final ExecutorService executorService = Executors.newCachedThreadPool();
@@ -409,6 +412,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
     public static final int FILE_CHOOSER_REQUEST_CODE = 1000;
     public ValueCallback<Uri> mUploadMessage;
     public ValueCallback<Uri[]> mFilePathCallback;
+    FileChooserRequestSupport.FileChooserRequest activeFileChooserRequest;
     private boolean openWebViewResolved;
     private boolean isDismissing = false;
     private PermissionRequest pendingCameraLaunchPermissionRequest;
@@ -2232,6 +2236,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
             _webView.addJavascriptInterface(proxyBridge, "__capgoProxy");
             proxyBridgeScript = loadProxyBridgeScript();
         }
+        ensureBundledAssetLoader();
         _webView.getSettings().setJavaScriptEnabled(true);
         _webView.getSettings().setJavaScriptCanOpenWindowsAutomatically(true);
         _webView.getSettings().setDatabaseEnabled(true);
@@ -2344,12 +2349,9 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                     );
 
                     // Check if the file chooser is already open
-                    if (mFilePathCallback != null) {
-                        mFilePathCallback.onReceiveValue(null);
-                        mFilePathCallback = null;
-                    }
-
-                    mFilePathCallback = filePathCallback;
+                    final boolean isMultiple = fileChooserParams.getMode() == FileChooserParams.MODE_OPEN_MULTIPLE;
+                    beginFileChooserRequest(filePathCallback, acceptType, isMultiple);
+                    final FileChooserRequestSupport.FileChooserRequest request = activeFileChooserRequest;
 
                     // Direct check for capture attribute in URL (fallback method)
                     boolean isCaptureInUrl;
@@ -2424,12 +2426,16 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                             """;
 
                         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"));
+                                launchCamera(captureMode.equals("user"), request);
                                 return;
                             }
 
@@ -2440,7 +2446,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                                 Log.d("InAppBrowser", "Found capture attribute: " + captureValue);
 
                                 if (!captureValue.isEmpty()) {
-                                    activity.runOnUiThread(() -> launchCamera(captureValue.equals("user")));
+                                    activity.runOnUiThread(() -> launchCamera(captureValue.equals("user"), request));
                                     return;
                                 }
                             }
@@ -2448,6 +2454,10 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                             // 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");
@@ -2460,25 +2470,21 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                                         (currentUrl.contains("selfie") || currentUrl.contains("camera") || currentUrl.contains("photo"))
                                     ) {
                                         Log.d("InAppBrowser", "URL suggests camera usage, launching camera");
-                                        activity.runOnUiThread(() -> launchCamera(currentUrl.contains("selfie")));
+                                        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(
-                                    filePathCallback,
-                                    acceptType,
-                                    fileChooserParams.getMode() == FileChooserParams.MODE_OPEN_MULTIPLE
-                                );
+                                openFileChooser(request);
                             });
                         });
                         return true;
                     }
 
                     // For non-image types, use regular file picker
-                    openFileChooser(filePathCallback, acceptType, fileChooserParams.getMode() == FileChooserParams.MODE_OPEN_MULTIPLE);
+                    openFileChooser(request);
                     return true;
                 }
 
@@ -2486,7 +2492,11 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                  * Launch the camera app for capturing images
                  * @param useFrontCamera true to use front camera, false for back camera
                  */
-                private void launchCamera(boolean useFrontCamera) {
+                private void launchCamera(boolean useFrontCamera, FileChooserRequestSupport.FileChooserRequest request) {
+                    if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                        return;
+                    }
+
                     Log.d("InAppBrowser", "Launching camera, front camera: " + useFrontCamera);
 
                     // First check if we have camera permission
@@ -2510,8 +2520,11 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                                     Log.d("InAppBrowser", "Ignoring delayed camera permission grant during dismiss");
                                     return;
                                 }
+                                if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                                    return;
+                                }
                                 // Permission granted, now launch the camera
-                                launchCameraWithPermission(useFrontCamera);
+                                launchCameraWithPermission(useFrontCamera, request);
                             }
 
                             @Override
@@ -2521,9 +2534,12 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                                     Log.d("InAppBrowser", "Ignoring delayed camera permission denial during dismiss");
                                     return;
                                 }
+                                if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                                    return;
+                                }
                                 // Permission denied, fall back to file picker
                                 Log.e("InAppBrowser", "Camera permission denied, falling back to file picker");
-                                fallbackToFilePicker();
+                                fallbackToFilePicker(request);
                             }
                         };
 
@@ -2535,13 +2551,17 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                     }
 
                     // If we can't request permission, try launching directly
-                    launchCameraWithPermission(useFrontCamera);
+                    launchCameraWithPermission(useFrontCamera, request);
                 }
 
                 /**
                  * Launch camera after permission is granted
                  */
-                private void launchCameraWithPermission(boolean useFrontCamera) {
+                private void launchCameraWithPermission(boolean useFrontCamera, FileChooserRequestSupport.FileChooserRequest request) {
+                    if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                        return;
+                    }
+
                     try {
                         Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                         if (takePictureIntent.resolveActivity(activity.getPackageManager()) != null) {
@@ -2550,17 +2570,18 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                                 photoFile = createImageFile();
                             } catch (IOException ex) {
                                 Log.e("InAppBrowser", "Error creating image file", ex);
-                                fallbackToFilePicker();
+                                fallbackToFilePicker(request);
                                 return;
                             }
 
                             if (photoFile != null) {
-                                tempCameraUri = FileProvider.getUriForFile(
+                                request.tempCameraUri = FileProvider.getUriForFile(
                                     activity,
                                     activity.getPackageName() + ".fileprovider",
                                     photoFile
                                 );
-                                takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, tempCameraUri);
+                                syncFileChooserPublicFields();
+                                takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, request.tempCameraUri);
 
                                 if (useFrontCamera) {
                                     takePictureIntent.putExtra("android.intent.extras.CAMERA_FACING", 1);
@@ -2576,15 +2597,23 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                                                 "camera_capture",
                                                 new androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult(),
                                                 (result) -> {
-                                                    if (result.getResultCode() == Activity.RESULT_OK) {
-                                                        if (tempCameraUri != null) {
-                                                            mFilePathCallback.onReceiveValue(new Uri[] { tempCameraUri });
-                                                        }
-                                                    } else {
-                                                        mFilePathCallback.onReceiveValue(null);
+                                                    if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                                                        return;
+                                                    }
+                                                    Uri[] results = null;
+                                                    if (result.getResultCode() == Activity.RESULT_OK && request.tempCameraUri != null) {
+                                                        results = new Uri[] { request.tempCameraUri };
+                                                    }
+                                                    if (
+                                                        FileChooserRequestSupport.completeIfActive(
+                                                            request,
+                                                            activeFileChooserRequest,
+                                                            results
+                                                        )
+                                                    ) {
+                                                        request.tempCameraUri = null;
+                                                        clearActiveFileChooserRequest(request);
                                                     }
-                                                    mFilePathCallback = null;
-                                                    tempCameraUri = null;
                                                 }
                                             )
                                             .launch(takePictureIntent);
@@ -2594,26 +2623,27 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                                     }
                                 } catch (SecurityException e) {
                                     Log.e("InAppBrowser", "Security exception launching camera: " + e.getMessage(), e);
-                                    fallbackToFilePicker();
+                                    fallbackToFilePicker(request);
                                 }
                             } else {
                                 Log.e("InAppBrowser", "Failed to create photo URI, falling back to file picker");
-                                fallbackToFilePicker();
+                                fallbackToFilePicker(request);
                             }
                         }
                     } catch (Exception e) {
                         Log.e("InAppBrowser", "Camera launch failed: " + e.getMessage(), e);
-                        fallbackToFilePicker();
+                        fallbackToFilePicker(request);
                     }
                 }
 
                 /**
                  * Fall back to file picker when camera launch fails
                  */
-                private void fallbackToFilePicker() {
-                    if (mFilePathCallback != null) {
-                        openFileChooser(mFilePathCallback, "image/*", false);
+                private void fallbackToFilePicker(FileChooserRequestSupport.FileChooserRequest request) {
+                    if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                        return;
                     }
+                    openFileChooser(request);
                 }
 
                 // Grant permissions for cam
@@ -4061,8 +4091,43 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
         }
     }
 
-    private void openFileChooser(ValueCallback<Uri[]> filePathCallback, String acceptType, boolean isMultiple) {
-        mFilePathCallback = filePathCallback;
+    private void beginFileChooserRequest(ValueCallback<Uri[]> filePathCallback, String acceptType, boolean isMultiple) {
+        if (activeFileChooserRequest != null) {
+            FileChooserRequestSupport.cancel(activeFileChooserRequest);
+        }
+        activeFileChooserRequest = new FileChooserRequestSupport.FileChooserRequest(filePathCallback, acceptType, isMultiple);
+        syncFileChooserPublicFields();
+    }
+
+    private void clearActiveFileChooserRequest(FileChooserRequestSupport.FileChooserRequest request) {
+        if (activeFileChooserRequest == request) {
+            activeFileChooserRequest = null;
+            syncFileChooserPublicFields();
+        }
+    }
+
+    private void syncFileChooserPublicFields() {
+        mFilePathCallback = activeFileChooserRequest != null ? activeFileChooserRequest.callback : null;
+        tempCameraUri = activeFileChooserRequest != null ? activeFileChooserRequest.tempCameraUri : null;
+    }
+
+    void completeLegacyFileChooserResult(Uri[] results) {
+        FileChooserRequestSupport.FileChooserRequest request = activeFileChooserRequest;
+        if (request == null) {
+            return;
+        }
+        if (FileChooserRequestSupport.completeIfActive(request, activeFileChooserRequest, results)) {
+            request.tempCameraUri = null;
+            clearActiveFileChooserRequest(request);
+        }
+    }
+
+    private void openFileChooser(FileChooserRequestSupport.FileChooserRequest request) {
+        if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+            return;
+        }
+        String acceptType = request.acceptType;
+        boolean isMultiple = request.multiple;
         Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
         intent.addCategory(Intent.CATEGORY_OPENABLE);
 
@@ -4110,26 +4175,29 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                         "file_chooser",
                         new androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult(),
                         (result) -> {
+                            if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                                return;
+                            }
+                            Uri[] results = null;
                             if (result.getResultCode() == Activity.RESULT_OK) {
                                 Intent data = result.getData();
                                 if (data != null) {
                                     if (data.getClipData() != null) {
                                         // Handle multiple files
                                         int count = data.getClipData().getItemCount();
-                                        Uri[] results = new Uri[count];
+                                        results = new Uri[count];
                                         for (int i = 0; i < count; i++) {
                                             results[i] = data.getClipData().getItemAt(i).getUri();
                                         }
-                                        mFilePathCallback.onReceiveValue(results);
                                     } else if (data.getData() != null) {
                                         // Handle single file
-                                        mFilePathCallback.onReceiveValue(new Uri[] { data.getData() });
+                                        results = new Uri[] { data.getData() };
                                     }
                                 }
-                            } else {
-                                mFilePathCallback.onReceiveValue(null);
                             }
-                            mFilePathCallback = null;
+                            if (FileChooserRequestSupport.completeIfActive(request, activeFileChooserRequest, results)) {
+                                clearActiveFileChooserRequest(request);
+                            }
                         }
                     )
                     .launch(Intent.createChooser(intent, "Select File"));
@@ -4150,26 +4218,29 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                             "file_chooser",
                             new androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult(),
                             (result) -> {
+                                if (!FileChooserRequestSupport.isActive(request, activeFileChooserRequest)) {
+                                    return;
+                                }
+                                Uri[] results = null;
                                 if (result.getResultCode() == Activity.RESULT_OK) {
                                     Intent data = result.getData();
                                     if (data != null) {
                                         if (data.getClipData() != null) {
                                             // Handle multiple files
                                             int count = data.getClipData().getItemCount();
-                                            Uri[] results = new Uri[count];
+                                            results = new Uri[count];
                                             for (int i = 0; i < count; i++) {
                                                 results[i] = data.getClipData().getItemAt(i).getUri();
                                             }
-                                            mFilePathCallback.onReceiveValue(results);
                                         } else if (data.getData() != null) {
                                             // Handle single file
-                                            mFilePathCallback.onReceiveValue(new Uri[] { data.getData() });
+                                            results = new Uri[] { data.getData() };
                                         }
                                     }
-                                } else {
-                                    mFilePathCallback.onReceiveValue(null);
                                 }
-                                mFilePathCallback = null;
+                                if (FileChooserRequestSupport.completeIfActive(request, activeFileChooserRequest, results)) {
+                                    clearActiveFileChooserRequest(request);
+                                }
                             }
                         )
                         .launch(Intent.createChooser(intent, "Select File"));
@@ -4180,9 +4251,8 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
             } catch (ActivityNotFoundException ex) {
                 // If still failing, report error
                 Log.e("InAppBrowser", "No app can handle file picker", ex);
-                if (mFilePathCallback != null) {
-                    mFilePathCallback.onReceiveValue(null);
-                    mFilePathCallback = null;
+                if (FileChooserRequestSupport.cancelIfActive(request, activeFileChooserRequest)) {
+                    clearActiveFileChooserRequest(request);
                 }
             }
         }
@@ -4364,6 +4434,60 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
         return proxyHeaders;
     }
 
+    private void ensureBundledAssetLoader() {
+        synchronized (bundledAssetLoaderLock) {
+            ensureBundledAssetLoaderLocked();
+        }
+    }
+
+    private void ensureBundledAssetLoaderLocked() {
+        if (bundledAssetLoader != null || _options == null || !_options.getServeBundledAssets()) {
+            return;
+        }
+
+        bundledAssetLoader = BundledAssetSupport.createAssetLoader(
+            _context,
+            _options.getBundledAssetHost(),
+            _options.getBundledAssetScheme()
+        );
+    }
+
+    public void applyBundledAssetResolution(BundledAssetSupport.Resolution resolution, String localUrl) {
+        if (_options == null || resolution == null) {
+            return;
+        }
+
+        synchronized (bundledAssetLoaderLock) {
+            bundledAssetLoader = null;
+            _options.setUrl(resolution.url);
+            if (resolution.needsAssetLoader) {
+                BundledAssetSupport.LocalConfig localConfig = BundledAssetSupport.parseLocalConfig(localUrl);
+                _options.setBundledAssetHost(localConfig != null ? localConfig.host : "localhost");
+                _options.setBundledAssetScheme(localConfig != null ? BundledAssetSupport.assetLoaderScheme(localConfig) : "https");
+                _options.setServeBundledAssets(true);
+            } else {
+                _options.setServeBundledAssets(false);
+            }
+        }
+    }
+
+    private WebResourceResponse interceptBundledAssetRequest(WebResourceRequest request) {
+        final WebViewAssetLoader loader;
+        synchronized (bundledAssetLoaderLock) {
+            if (_options == null || !_options.getServeBundledAssets()) {
+                return null;
+            }
+
+            ensureBundledAssetLoaderLocked();
+            loader = bundledAssetLoader;
+        }
+
+        if (loader == null) {
+            return null;
+        }
+        return loader.shouldInterceptRequest(request.getUrl());
+    }
+
     public void setUrl(String url) {
         if (_webView == null) {
             Log.w("InAppBrowser", "Cannot set URL - WebView is null");
@@ -5586,186 +5710,254 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                     if (view == null || _webView == null) {
                         return null;
                     }
-                    if (!shouldUseNativeProxy()) {
-                        return null;
-                    }
 
-                    String requestUrl = request.getUrl().toString();
-                    boolean bridgeBackedRequest = ProxyRequestSupport.isBridgeMarkerRequestUrl(requestUrl);
-                    String originalUrl;
-                    String method;
-                    Map<String, String> requestHeaders = new HashMap<>();
-                    String base64Body = "";
-                    String credentialsMode = "same-origin";
-
-                    if (bridgeBackedRequest) {
-                        Uri uri = request.getUrl();
-                        originalUrl = uri.getQueryParameter("u");
-                        String requestId = uri.getQueryParameter("rid");
-                        if (originalUrl == null || requestId == null) {
-                            return null;
-                        }
+                    if (shouldUseNativeProxy()) {
+                        String requestUrl = request.getUrl().toString();
+                        boolean bridgeBackedRequest = ProxyRequestSupport.isBridgeMarkerRequestUrl(requestUrl);
+                        String originalUrl;
+                        String method;
+                        Map<String, String> requestHeaders = new HashMap<>();
+                        String base64Body = "";
+                        String credentialsMode = "same-origin";
+
+                        if (bridgeBackedRequest) {
+                            Uri uri = request.getUrl();
+                            originalUrl = uri.getQueryParameter("u");
+                            String requestId = uri.getQueryParameter("rid");
+                            if (originalUrl == null || requestId == null) {
+                                return null;
+                            }
 
-                        if (
-                            ProxyRequestSupport.usesLegacyJsProxyMode(_options) &&
-                            !ProxyRequestSupport.shouldDelegateLegacyJsProxyRequest(_options, originalUrl)
-                        ) {
-                            if (proxyBridge != null) {
-                                proxyBridge.getAndRemove(requestId);
+                            if (
+                                ProxyRequestSupport.usesLegacyJsProxyMode(_options) &&
+                                !ProxyRequestSupport.shouldDelegateLegacyJsProxyRequest(_options, originalUrl)
+                            ) {
+                                if (proxyBridge != null) {
+                                    proxyBridge.getAndRemove(requestId);
+                                }
+                                Log.w("InAppBrowserProxy", "Ignoring legacy regex miss for bridge-backed request: " + originalUrl);
+                                return createCanceledResponse();
                             }
-                            Log.w("InAppBrowserProxy", "Ignoring legacy regex miss for bridge-backed request: " + originalUrl);
-                            return createCanceledResponse();
-                        }
 
-                        ProxyBridge.StoredRequest stored = proxyBridge != null ? proxyBridge.getAndRemove(requestId) : null;
-                        if (stored == null) {
-                            Log.e("InAppBrowserProxy", "Missing stored proxy bridge payload for request id: " + requestId);
-                            return createCanceledResponse();
-                        }
-                        method = stored.method;
-                        base64Body = stored.base64Body;
-                        credentialsMode = stored.credentialsMode;
-                        Map<String, String> safeMarkerHeaders = ProxyRequestSupport.extractSafeMarkerHeaders(request.getRequestHeaders());
-                        try {
-                            requestHeaders = ProxyRequestSupport.mergeRequestHeaders(null, stored.headersJson);
-                            requestHeaders = ProxyRequestSupport.mergeMissingHeaders(requestHeaders, safeMarkerHeaders);
-                        } catch (JSONException error) {
-                            Log.e("InAppBrowserProxy", "Failed to parse stored proxy headers", error);
-                            return createCanceledResponse();
-                        }
-                        String initiatorUrl = request.getRequestHeaders().get("Referer");
-                        if (initiatorUrl == null || initiatorUrl.isBlank()) {
-                            initiatorUrl = getWebViewUrlOrFallback(
-                                _options != null && _options.getUrl() != null ? _options.getUrl() : originalUrl
+                            ProxyBridge.StoredRequest stored = proxyBridge != null ? proxyBridge.getAndRemove(requestId) : null;
+                            if (stored == null) {
+                                Log.e("InAppBrowserProxy", "Missing stored proxy bridge payload for request id: " + requestId);
+                                return createCanceledResponse();
+                            }
+                            method = stored.method;
+                            base64Body = stored.base64Body;
+                            credentialsMode = stored.credentialsMode;
+                            Map<String, String> safeMarkerHeaders = ProxyRequestSupport.extractSafeMarkerHeaders(
+                                request.getRequestHeaders()
                             );
+                            try {
+                                requestHeaders = ProxyRequestSupport.mergeRequestHeaders(null, stored.headersJson);
+                                requestHeaders = ProxyRequestSupport.mergeMissingHeaders(requestHeaders, safeMarkerHeaders);
+                            } catch (JSONException error) {
+                                Log.e("InAppBrowserProxy", "Failed to parse stored proxy headers", error);
+                                return createCanceledResponse();
+                            }
+                            String initiatorUrl = request.getRequestHeaders().get("Referer");
+                            if (initiatorUrl == null || initiatorUrl.isBlank()) {
+                                initiatorUrl = getWebViewUrlOrFallback(
+                                    _options != null && _options.getUrl() != null ? _options.getUrl() : originalUrl
+                                );
+                            }
+                            String targetCookies = CookieManager.getInstance().getCookie(originalUrl);
+                            if (
+                                targetCookies != null &&
+                                !targetCookies.isBlank() &&
+                                ProxyRequestSupport.shouldInjectCookies(credentialsMode, initiatorUrl, originalUrl, requestHeaders)
+                            ) {
+                                requestHeaders.put("Cookie", targetCookies);
+                            }
+                        } else {
+                            if (!ProxyRequestSupport.shouldHandleNonBridgeRequest(_options, requestUrl)) {
+                                return interceptBundledAssetRequest(request);
+                            }
+
+                            originalUrl = requestUrl;
+                            method = request.getMethod();
+                            if (request.getRequestHeaders() != null) {
+                                requestHeaders.putAll(request.getRequestHeaders());
+                            }
                         }
-                        String targetCookies = CookieManager.getInstance().getCookie(originalUrl);
+
+                        NativeRequestContext requestContext = new NativeRequestContext(
+                            originalUrl,
+                            method,
+                            requestHeaders,
+                            base64Body,
+                            request.isForMainFrame(),
+                            credentialsMode
+                        );
+
                         if (
-                            targetCookies != null &&
-                            !targetCookies.isBlank() &&
-                            ProxyRequestSupport.shouldInjectCookies(credentialsMode, initiatorUrl, originalUrl, requestHeaders)
+                            ProxyRequestSupport.shouldLetWebViewHandleMissingBody(
+                                requestUrl,
+                                requestContext.method,
+                                requestContext.base64Body
+                            )
                         ) {
-                            requestHeaders.put("Cookie", targetCookies);
-                        }
-                    } else {
-                        if (!ProxyRequestSupport.shouldHandleNonBridgeRequest(_options, requestUrl)) {
+                            Log.w("InAppBrowserProxy", "Allowing WebView to handle request with uncaptured body: " + requestContext.url);
                             return null;
                         }
 
-                        originalUrl = requestUrl;
-                        method = request.getMethod();
-                        if (request.getRequestHeaders() != null) {
-                            requestHeaders.putAll(request.getRequestHeaders());
+                        boolean legacyProxyMode = ProxyRequestSupport.usesLegacyJsProxyMode(_options);
+                        boolean shouldDelegateLegacyRequest = ProxyRequestSupport.shouldDelegateLegacyJsProxyRequest(
+                            _options,
+                            requestContext.url
+                        );
+                        NativeResponseData directResponseData = null;
+
+                        NativeProxyRule outboundRule =
+                            legacyProxyMode && shouldDelegateLegacyRequest
+                                ? new NativeProxyRule(
+                                      null,
+                                      null,
+                                      null,
+                                      null,
+                                      null,
+                                      null,
+                                      null,
+                                      null,
+                                      false,
+                                      NativeProxyRule.Action.DELEGATE_TO_JS
+                                  )
+                                : findMatchingRule(_options.getOutboundProxyRules(), requestContext, null);
+
+                        if (outboundRule != null && outboundRule.getAction() == NativeProxyRule.Action.CANCEL) {
+                            return createCanceledResponse();
                         }
-                    }
-
-                    NativeRequestContext requestContext = new NativeRequestContext(
-                        originalUrl,
-                        method,
-                        requestHeaders,
-                        base64Body,
-                        request.isForMainFrame(),
-                        credentialsMode
-                    );
-
-                    if (
-                        ProxyRequestSupport.shouldLetWebViewHandleMissingBody(requestUrl, requestContext.method, requestContext.base64Body)
-                    ) {
-                        Log.w("InAppBrowserProxy", "Allowing WebView to handle request with uncaptured body: " + requestContext.url);
-                        return null;
-                    }
 
-                    boolean legacyProxyMode = ProxyRequestSupport.usesLegacyJsProxyMode(_options);
-                    boolean shouldDelegateLegacyRequest = ProxyRequestSupport.shouldDelegateLegacyJsProxyRequest(
-                        _options,
-                        requestContext.url
-                    );
-                    NativeResponseData directResponseData = null;
-
-                    NativeProxyRule outboundRule =
-                        legacyProxyMode && shouldDelegateLegacyRequest
-                            ? new NativeProxyRule(
-                                  null,
-                                  null,
-                                  null,
-                                  null,
-                                  null,
-                                  null,
-                                  null,
-                                  null,
-                                  false,
-                                  NativeProxyRule.Action.DELEGATE_TO_JS
-                              )
-                            : findMatchingRule(_options.getOutboundProxyRules(), requestContext, null);
-
-                    if (outboundRule != null && outboundRule.getAction() == NativeProxyRule.Action.CANCEL) {
-                        return createCanceledResponse();
-                    }
-
-                    if (outboundRule != null && outboundRule.getAction() == NativeProxyRule.Action.DELEGATE_TO_JS) {
-                        String proxyId = UUID.randomUUID().toString();
-                        ProxiedRequest proxiedRequest = new ProxiedRequest();
-                        proxiedRequest.requestContext = requestContext;
-                        addProxiedRequest(proxyId, proxiedRequest);
-
-                        String dialogId = instanceId != null ? instanceId : "";
-                        _options
-                            .getCallbacks()
-                            .proxyRequestEvent(
-                                proxyId,
-                                "outbound",
-                                requestContext.url,
-                                requestContext.method,
-                                serializeHeaders(requestContext.headers),
-                                requestContext.base64Body.isEmpty() ? null : requestContext.base64Body,
-                                null,
-                                null,
-                                null,
-                                dialogId
-                            );
+                        if (outboundRule != null && outboundRule.getAction() == NativeProxyRule.Action.DELEGATE_TO_JS) {
+                            String proxyId = UUID.randomUUID().toString();
+                            ProxiedRequest proxiedRequest = new ProxiedRequest();
+                            proxiedRequest.requestContext = requestContext;
+                            addProxiedRequest(proxyId, proxiedRequest);
+
+                            String dialogId = instanceId != null ? instanceId : "";
+                            _options
+                                .getCallbacks()
+                                .proxyRequestEvent(
+                                    proxyId,
+                                    "outbound",
+                                    requestContext.url,
+                                    requestContext.method,
+                                    serializeHeaders(requestContext.headers),
+                                    requestContext.base64Body.isEmpty() ? null : requestContext.base64Body,
+                                    null,
+                                    null,
+                                    null,
+                                    dialogId
+                                );
 
-                        try {
-                            if (proxiedRequest.semaphore.tryAcquire(1, 10, TimeUnit.SECONDS)) {
-                                if (proxiedRequest.canceled) {
-                                    return createCanceledResponse();
-                                }
-                                if (proxiedRequest.response != null) {
-                                    return proxiedRequest.response;
-                                }
-                                if (proxiedRequest.nativeResponse != null) {
-                                    directResponseData = proxiedRequest.nativeResponse;
+                            try {
+                                if (proxiedRequest.semaphore.tryAcquire(1, 10, TimeUnit.SECONDS)) {
+                                    if (proxiedRequest.canceled) {
+                                        return createCanceledResponse();
+                                    }
+                                    if (proxiedRequest.response != null) {
+                                        return proxiedRequest.response;
+                                    }
+                                    if (proxiedRequest.nativeResponse != null) {
+                                        directResponseData = proxiedRequest.nativeResponse;
+                                    } else {
+                                        requestContext =
+                                            proxiedRequest.requestContext != null ? proxiedRequest.requestContext : requestContext;
+                                    }
                                 } else {
-                                    requestContext = proxiedRequest.requestContext != null ? proxiedRequest.requestContext : requestContext;
-                                }
-                            } else {
-                                synchronized (proxiedRequest) {
-                                    proxiedRequest.timedOut = true;
+                                    synchronized (proxiedRequest) {
+                                        proxiedRequest.timedOut = true;
+                                    }
+                                    removeProxiedRequest(proxyId);
+                                    Log.w("InAppBrowserProxy", "Proxy timeout, falling back to native replay for: " + requestContext.url);
                                 }
+                            } catch (InterruptedException error) {
                                 removeProxiedRequest(proxyId);
-                                Log.w("InAppBrowserProxy", "Proxy timeout, falling back to native replay for: " + requestContext.url);
+                                Thread.currentThread().interrupt();
+                                Log.e("InAppBrowserProxy", "Semaphore wait error", error);
+                                return bridgeBackedRequest ? createCanceledResponse() : null;
                             }
-                        } catch (InterruptedException error) {
-                            removeProxiedRequest(proxyId);
-                            Thread.currentThread().interrupt();
-                            Log.e("InAppBrowserProxy", "Semaphore wait error", error);
-                            return bridgeBackedRequest ? createCanceledResponse() : null;
                         }
-                    }
 
-                    NativeResponseData nativeResponse = directResponseData;
-                    if (nativeResponse == null) {
-                        try {
-                            nativeResponse = performNativeRequest(requestContext);
-                        } catch (IOException error) {
-                            Log.e("InAppBrowserProxy", "Native request failed for: " + requestContext.url, error);
-                            return createProxiedNativeFailureResponse(requestContext.url, bridgeBackedRequest, error);
+                        NativeResponseData nativeResponse = directResponseData;
+                        if (nativeResponse == null) {
+                            try {
+                                nativeResponse = performNativeRequest(requestContext);
+                            } catch (IOException error) {
+                                Log.e("InAppBrowserProxy", "Native request failed for: " + requestContext.url, error);
+                                return createProxiedNativeFailureResponse(requestContext.url, bridgeBackedRequest, error);
+                            }
                         }
-                    }
 
-                    int redirectsFollowed = 0;
-                    while (true) {
-                        NativeProxyRule inboundRule = findMatchingRule(_options.getInboundProxyRules(), requestContext, nativeResponse);
-                        if (inboundRule == null || inboundRule.getAction() == NativeProxyRule.Action.CONTINUE) {
+                        int redirectsFollowed = 0;
+                        while (true) {
+                            NativeProxyRule inboundRule = findMatchingRule(_options.getInboundProxyRules(), requestContext, nativeResponse);
+                            if (inboundRule == null || inboundRule.getAction() == NativeProxyRule.Action.CONTINUE) {
+                                RedirectReplayResult redirectReplay;
+                                try {
+                                    redirectReplay = followRedirectForWebView(requestContext, nativeResponse, redirectsFollowed);
+                                } catch (IOException error) {
+                                    Log.e("InAppBrowserProxy", "Native redirect replay failed for: " + requestContext.url, error);
+                                    return createProxiedNativeFailureResponse(requestContext.url, bridgeBackedRequest, error);
+                                }
+                                if (redirectReplay != null) {
+                                    requestContext = redirectReplay.requestContext;
+                                    nativeResponse = redirectReplay.responseData;
+                                    redirectsFollowed++;
+                                    continue;
+                                }
+                                return createWebResourceResponseOrFallback(nativeResponse, bridgeBackedRequest, requestContext.url);
+                            }
+                            if (inboundRule.getAction() == NativeProxyRule.Action.CANCEL) {
+                                return createCanceledResponse();
+                            }
+
+                            String proxyId = UUID.randomUUID().toString();
+                            ProxiedRequest proxiedRequest = new ProxiedRequest();
+                            proxiedRequest.requestContext = requestContext;
+                            proxiedRequest.nativeResponse = nativeResponse;
+                            addProxiedRequest(proxyId, proxiedRequest);
+
+                            String dialogId = instanceId != null ? instanceId : "";
+                            _options
+                                .getCallbacks()
+                                .proxyRequestEvent(
+                                    proxyId,
+                                    "inbound",
+                                    requestContext.url,
+                                    requestContext.method,
+                                    serializeHeaders(requestContext.headers),
+                                    requestContext.base64Body.isEmpty() ? null : requestContext.base64Body,
+                                    nativeResponse.statusCode,
+                                    serializeHeaders(nativeResponse.headers),
+                                    Base64.encodeToString(nativeResponse.bodyBytes, Base64.NO_WRAP),
+                                    dialogId
+                                );
+
+                            try {
+                                if (proxiedRequest.semaphore.tryAcquire(1, 10, TimeUnit.SECONDS)) {
+                                    if (proxiedRequest.canceled) {
+                                        return createCanceledResponse();
+                                    }
+                                    if (proxiedRequest.response != null) {
+                                        return proxiedRequest.response;
+                                    }
+                                    if (proxiedRequest.nativeResponse != null) {
+                                        nativeResponse = proxiedRequest.nativeResponse;
+                                    }
+                                } else {
+                                    synchronized (proxiedRequest) {
+                                        proxiedRequest.timedOut = true;
+                                    }
+                                    removeProxiedRequest(proxyId);
+                                }
+                            } catch (InterruptedException error) {
+                                Thread.currentThread().interrupt();
+                                Log.e("InAppBrowserProxy", "Semaphore wait error", error);
+                            }
+
                             RedirectReplayResult redirectReplay;
                             try {
                                 redirectReplay = followRedirectForWebView(requestContext, nativeResponse, redirectsFollowed);
@@ -5781,69 +5973,9 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                             }
                             return createWebResourceResponseOrFallback(nativeResponse, bridgeBackedRequest, requestContext.url);
                         }
-                        if (inboundRule.getAction() == NativeProxyRule.Action.CANCEL) {
-                            return createCanceledResponse();
-                        }
-
-                        String proxyId = UUID.randomUUID().toString();
-                        ProxiedRequest proxiedRequest = new ProxiedRequest();
-                        proxiedRequest.requestContext = requestContext;
-                        proxiedRequest.nativeResponse = nativeResponse;
-                        addProxiedRequest(proxyId, proxiedRequest);
-
-                        String dialogId = instanceId != null ? instanceId : "";
-                        _options
-                            .getCallbacks()
-                            .proxyRequestEvent(
-                                proxyId,
-                                "inbound",
-                                requestContext.url,
-                                requestContext.method,
-                                serializeHeaders(requestContext.headers),
-                                requestContext.base64Body.isEmpty() ? null : requestContext.base64Body,
-                                nativeResponse.statusCode,
-                                serializeHeaders(nativeResponse.headers),
-                                Base64.encodeToString(nativeResponse.bodyBytes, Base64.NO_WRAP),
-                                dialogId
-                            );
-
-                        try {
-                            if (proxiedRequest.semaphore.tryAcquire(1, 10, TimeUnit.SECONDS)) {
-                                if (proxiedRequest.canceled) {
-                                    return createCanceledResponse();
-                                }
-                                if (proxiedRequest.response != null) {
-                                    return proxiedRequest.response;
-                                }
-                                if (proxiedRequest.nativeResponse != null) {
-                                    nativeResponse = proxiedRequest.nativeResponse;
-                                }
-                            } else {
-                                synchronized (proxiedRequest) {
-                                    proxiedRequest.timedOut = true;
-                                }
-                                removeProxiedRequest(proxyId);
-                            }
-                        } catch (InterruptedException error) {
-                            Thread.currentThread().interrupt();
-                            Log.e("InAppBrowserProxy", "Semaphore wait error", error);
-                        }
-
-                        RedirectReplayResult redirectReplay;
-                        try {
-                            redirectReplay = followRedirectForWebView(requestContext, nativeResponse, redirectsFollowed);
-                        } catch (IOException error) {
-                            Log.e("InAppBrowserProxy", "Native redirect replay failed for: " + requestContext.url, error);
-                            return createProxiedNativeFailureResponse(requestContext.url, bridgeBackedRequest, error);
-                        }
-                        if (redirectReplay != null) {
-                            requestContext = redirectReplay.requestContext;
-                            nativeResponse = redirectReplay.responseData;
-                            redirectsFollowed++;
-                            continue;
-                        }
-                        return createWebResourceResponseOrFallback(nativeResponse, bridgeBackedRequest, requestContext.url);
                     }
+
+                    return interceptBundledAssetRequest(request);
                 }
 
                 @Override
@@ -6192,11 +6324,11 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                 }
 
                 // Clear any pending callbacks to prevent memory leaks
-                if (mFilePathCallback != null) {
-                    mFilePathCallback.onReceiveValue(null);
-                    mFilePathCallback = null;
+                if (activeFileChooserRequest != null) {
+                    FileChooserRequestSupport.cancel(activeFileChooserRequest);
+                    activeFileChooserRequest = null;
+                    syncFileChooserPublicFields();
                 }
-                tempCameraUri = null;
 
                 // Clear file inputs for security/privacy before destroying WebView
                 try {