@capgo/capacitor-inappbrowser 8.15.0 → 8.15.2

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

@@ -574,9 +574,7 @@ public class CapgoInAppBrowserPlugin extends Plugin implements WebViewDialog.Per
             }
 
             // Send the result to WebView and clean up
-            webViewDialog.mFilePathCallback.onReceiveValue(results);
-            webViewDialog.mFilePathCallback = null;
-            webViewDialog.tempCameraUri = null;
+            webViewDialog.completeLegacyFileChooserResult(results);
         }
     }
 

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

@@ -0,0 +1,111 @@
+package ee.forgr.capacitor_inappbrowser;
+
+import android.content.Intent;
+import android.webkit.MimeTypeMap;
+import java.util.LinkedHashSet;
+import java.util.Locale;
+import java.util.function.Predicate;
+
+/**
+ * Normalizes WebView file-input accept attributes into Android file-chooser intents.
+ */
+final class FileChooserAcceptSupport {
+
+    private FileChooserAcceptSupport() {}
+
+    static String acceptEntryToMimeType(String accept) {
+        if (accept == null || accept.isEmpty() || accept.equals("undefined")) {
+            return null;
+        }
+        accept = accept.toLowerCase(Locale.ROOT);
+        if (accept.contains("/")) {
+            return accept;
+        }
+        if (!accept.startsWith(".")) {
+            return null;
+        }
+        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(accept.substring(1).toLowerCase(Locale.ROOT));
+    }
+
+    static LinkedHashSet<String> normalizeAcceptTypes(String[] acceptTypes) {
+        LinkedHashSet<String> mimeTypes = new LinkedHashSet<>();
+        if (acceptTypes != null) {
+            for (String entry : acceptTypes) {
+                if (entry == null) {
+                    continue;
+                }
+                for (String part : entry.split(",")) {
+                    String mime = acceptEntryToMimeType(part.trim());
+                    if (mime != null) {
+                        mimeTypes.add(mime);
+                    }
+                }
+            }
+        }
+        if (mimeTypes.contains("*/*")) {
+            mimeTypes.clear();
+        }
+        return mimeTypes;
+    }
+
+    static boolean isImageOnlyAcceptTypes(String[] acceptTypes) {
+        return matchesAllResolvedAcceptTypes(acceptTypes, (mime) -> mime.startsWith("image/"));
+    }
+
+    static boolean isMediaOnlyAcceptTypes(String[] acceptTypes) {
+        return matchesAllResolvedAcceptTypes(
+            acceptTypes,
+            (mime) -> mime.startsWith("image/") || mime.startsWith("video/") || mime.startsWith("audio/")
+        );
+    }
+
+    private static boolean matchesAllResolvedAcceptTypes(String[] acceptTypes, Predicate<String> mimePredicate) {
+        boolean foundMatch = false;
+        if (acceptTypes == null) {
+            return false;
+        }
+        for (String entry : acceptTypes) {
+            if (entry == null) {
+                continue;
+            }
+            for (String part : entry.split(",")) {
+                String token = part.trim();
+                if (token.isEmpty() || token.equals("undefined")) {
+                    continue;
+                }
+                String mime = acceptEntryToMimeType(token);
+                if (mime == null || mime.equals("*/*")) {
+                    return false;
+                }
+                if (!mimePredicate.test(mime)) {
+                    return false;
+                }
+                foundMatch = true;
+            }
+        }
+        return foundMatch;
+    }
+
+    static boolean useGetContentAction(String[] acceptTypes) {
+        LinkedHashSet<String> mimeTypes = normalizeAcceptTypes(acceptTypes);
+        return isMediaOnlyAcceptTypes(acceptTypes) && mimeTypes.size() == 1;
+    }
+
+    static Intent createFileChooserIntent(String[] acceptTypes, boolean multiple) {
+        LinkedHashSet<String> mimeTypes = normalizeAcceptTypes(acceptTypes);
+        Intent intent = new Intent(useGetContentAction(acceptTypes) ? Intent.ACTION_GET_CONTENT : Intent.ACTION_OPEN_DOCUMENT);
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+
+        if (mimeTypes.size() == 1) {
+            intent.setType(mimeTypes.iterator().next());
+        } else {
+            intent.setType("*/*");
+            if (!mimeTypes.isEmpty()) {
+                intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes.toArray(new String[0]));
+            }
+        }
+
+        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, multiple);
+        return intent;
+    }
+}

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

@@ -0,0 +1,53 @@
+package ee.forgr.capacitor_inappbrowser;
+
+import android.net.Uri;
+import android.webkit.ValueCallback;
+
+/**
+ * Request-scoped state for Android WebView file-chooser flows.
+ * Prevents overlapping chooser/camera requests from cross-delivering results.
+ */
+final class FileChooserRequestSupport {
+
+    static final class FileChooserRequest {
+
+        final ValueCallback<Uri[]> callback;
+        final String[] acceptTypes;
+        final boolean multiple;
+        Uri tempCameraUri;
+
+        FileChooserRequest(ValueCallback<Uri[]> callback, String[] acceptTypes, boolean multiple) {
+            this.callback = callback;
+            this.acceptTypes = acceptTypes;
+            this.multiple = multiple;
+        }
+    }
+
+    private FileChooserRequestSupport() {}
+
+    static boolean isActive(FileChooserRequest request, FileChooserRequest active) {
+        return request != null && request == active;
+    }
+
+    static void cancel(FileChooserRequest request) {
+        if (request != null && request.callback != null) {
+            request.callback.onReceiveValue(null);
+        }
+    }
+
+    static boolean completeIfActive(FileChooserRequest request, FileChooserRequest active, Uri[] results) {
+        if (!isActive(request, active)) {
+            return false;
+        }
+        request.callback.onReceiveValue(results);
+        return true;
+    }
+
+    static boolean cancelIfActive(FileChooserRequest request, FileChooserRequest active) {
+        if (!isActive(request, active)) {
+            return false;
+        }
+        request.callback.onReceiveValue(null);
+        return true;
+    }
+}

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

@@ -412,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;
@@ -2322,21 +2323,14 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                     ValueCallback<Uri[]> filePathCallback,
                     FileChooserParams fileChooserParams
                 ) {
-                    // Get the accept type safely
-                    String acceptType;
-                    if (
-                        fileChooserParams.getAcceptTypes() != null &&
-                        fileChooserParams.getAcceptTypes().length > 0 &&
-                        !TextUtils.isEmpty(fileChooserParams.getAcceptTypes()[0])
-                    ) {
-                        acceptType = fileChooserParams.getAcceptTypes()[0];
-                    } else {
-                        acceptType = "*/*";
+                    String[] acceptTypes = fileChooserParams.getAcceptTypes();
+                    if (acceptTypes == null || acceptTypes.length == 0) {
+                        acceptTypes = new String[] { "*/*" };
                     }
 
                     // DEBUG: Log details about the file chooser request
                     Log.d("InAppBrowser", "onShowFileChooser called");
-                    Log.d("InAppBrowser", "Accept type: " + acceptType);
+                    Log.d("InAppBrowser", "Accept types: " + Arrays.toString(acceptTypes));
                     Log.d("InAppBrowser", "Current URL: " + getUrl());
                     Log.d("InAppBrowser", "Original URL: " + (webView.getOriginalUrl() != null ? webView.getOriginalUrl() : "null"));
                     Log.d(
@@ -2348,12 +2342,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, acceptTypes, isMultiple);
+                    final FileChooserRequestSupport.FileChooserRequest request = activeFileChooserRequest;
 
                     // Direct check for capture attribute in URL (fallback method)
                     boolean isCaptureInUrl;
@@ -2370,8 +2361,10 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
                         isCaptureInUrl = false;
                     }
 
-                    // For image inputs, try to detect capture attribute using JavaScript
-                    if (acceptType.equals("image/*")) {
+                    // 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",
@@ -2428,12 +2421,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;
                             }
 
@@ -2444,7 +2441,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;
                                 }
                             }
@@ -2452,6 +2449,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");
@@ -2464,25 +2465,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;
                 }
 
@@ -2490,7 +2487,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
@@ -2514,8 +2515,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
@@ -2525,9 +2529,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);
                             }
                         };
 
@@ -2539,13 +2546,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) {
@@ -2554,17 +2565,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);
@@ -2580,15 +2592,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);
@@ -2598,26 +2618,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
@@ -4065,45 +4086,45 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
         }
     }
 
-    private void openFileChooser(ValueCallback<Uri[]> filePathCallback, String acceptType, boolean isMultiple) {
-        mFilePathCallback = filePathCallback;
-        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
-        intent.addCategory(Intent.CATEGORY_OPENABLE);
+    private void beginFileChooserRequest(ValueCallback<Uri[]> filePathCallback, String[] acceptTypes, boolean isMultiple) {
+        if (activeFileChooserRequest != null) {
+            FileChooserRequestSupport.cancel(activeFileChooserRequest);
+        }
+        activeFileChooserRequest = new FileChooserRequestSupport.FileChooserRequest(filePathCallback, acceptTypes, isMultiple);
+        syncFileChooserPublicFields();
+    }
 
-        // Fix MIME type handling
-        if (acceptType == null || acceptType.isEmpty() || acceptType.equals("undefined")) {
-            acceptType = "*/*";
-        } else {
-            // Handle common web input accept types
-            if (acceptType.equals("image/*")) {
-                // Keep as is - image/*
-            } else if (acceptType.contains("image/")) {
-                // Specific image type requested but keep it general for better compatibility
-                acceptType = "image/*";
-            } else if (acceptType.equals("audio/*") || acceptType.contains("audio/")) {
-                acceptType = "audio/*";
-            } else if (acceptType.equals("video/*") || acceptType.contains("video/")) {
-                acceptType = "video/*";
-            } else if (acceptType.startsWith(".") || acceptType.contains(",")) {
-                // Handle file extensions like ".pdf, .docx" by using a general mime type
-                if (acceptType.contains(".pdf")) {
-                    acceptType = "application/pdf";
-                } else if (acceptType.contains(".doc") || acceptType.contains(".docx")) {
-                    acceptType = "application/msword";
-                } else if (acceptType.contains(".xls") || acceptType.contains(".xlsx")) {
-                    acceptType = "application/vnd.ms-excel";
-                } else if (acceptType.contains(".txt") || acceptType.contains(".text")) {
-                    acceptType = "text/plain";
-                } else {
-                    // Default for extension lists
-                    acceptType = "*/*";
-                }
-            }
+    private void clearActiveFileChooserRequest(FileChooserRequestSupport.FileChooserRequest request) {
+        if (activeFileChooserRequest == request) {
+            activeFileChooserRequest = null;
+            syncFileChooserPublicFields();
         }
+    }
 
-        Log.d("InAppBrowser", "File picker using MIME type: " + acceptType);
-        intent.setType(acceptType);
-        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, isMultiple);
+    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;
+        }
+        java.util.LinkedHashSet<String> mimeTypes = FileChooserAcceptSupport.normalizeAcceptTypes(request.acceptTypes);
+        Intent intent = FileChooserAcceptSupport.createFileChooserIntent(request.acceptTypes, request.multiple);
+
+        Log.d("InAppBrowser", "File picker using action: " + intent.getAction() + ", MIME types: " + mimeTypes);
 
         try {
             if (activity instanceof androidx.activity.ComponentActivity) {
@@ -4114,26 +4135,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"));
@@ -4143,8 +4167,9 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
             }
         } catch (ActivityNotFoundException e) {
             // If no app can handle the specific MIME type, try with a more generic one
-            Log.e("InAppBrowser", "No app available for type: " + acceptType + ", trying with */*");
+            Log.e("InAppBrowser", "No app available for types: " + mimeTypes + ", trying with */*");
             intent.setType("*/*");
+            intent.removeExtra(Intent.EXTRA_MIME_TYPES);
             try {
                 if (activity instanceof androidx.activity.ComponentActivity) {
                     androidx.activity.ComponentActivity componentActivity = (androidx.activity.ComponentActivity) activity;
@@ -4154,26 +4179,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"));
@@ -4184,9 +4212,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);
                 }
             }
         }
@@ -6258,11 +6285,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 {

package/ios/Sources/InAppBrowserPlugin/InAppBrowserPlugin.swift

@@ -415,7 +415,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         case aware = "AWARE"
         case fakeVisible = "FAKE_VISIBLE"
     }
-    private let pluginVersion: String = "8.15.0"
+    private let pluginVersion: String = "8.15.2"
     public let identifier = "CapgoInAppBrowserPlugin"
     public let jsName = "CapgoInAppBrowser"
     public let pluginMethods: [CAPPluginMethod] = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-inappbrowser",
-  "version": "8.15.0",
+  "version": "8.15.2",
   "description": "Capacitor plugin in app browser",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",