@capgo/capacitor-inappbrowser 8.15.1 → 8.15.2

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

@@ -11,18 +11,14 @@ final class FileChooserRequestSupport {
 
     static final class FileChooserRequest {
 
-        private static long nextId = 0;
-
-        final long id;
         final ValueCallback<Uri[]> callback;
-        final String acceptType;
+        final String[] acceptTypes;
         final boolean multiple;
         Uri tempCameraUri;
 
-        FileChooserRequest(ValueCallback<Uri[]> callback, String acceptType, boolean multiple) {
-            this.id = ++nextId;
+        FileChooserRequest(ValueCallback<Uri[]> callback, String[] acceptTypes, boolean multiple) {
             this.callback = callback;
-            this.acceptType = acceptType;
+            this.acceptTypes = acceptTypes;
             this.multiple = multiple;
         }
     }

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

@@ -2323,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(
@@ -2350,7 +2343,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
 
                     // Check if the file chooser is already open
                     final boolean isMultiple = fileChooserParams.getMode() == FileChooserParams.MODE_OPEN_MULTIPLE;
-                    beginFileChooserRequest(filePathCallback, acceptType, isMultiple);
+                    beginFileChooserRequest(filePathCallback, acceptTypes, isMultiple);
                     final FileChooserRequestSupport.FileChooserRequest request = activeFileChooserRequest;
 
                     // Direct check for capture attribute in URL (fallback method)
@@ -2368,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",
@@ -4091,11 +4086,11 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
         }
     }
 
-    private void beginFileChooserRequest(ValueCallback<Uri[]> filePathCallback, String acceptType, boolean isMultiple) {
+    private void beginFileChooserRequest(ValueCallback<Uri[]> filePathCallback, String[] acceptTypes, boolean isMultiple) {
         if (activeFileChooserRequest != null) {
             FileChooserRequestSupport.cancel(activeFileChooserRequest);
         }
-        activeFileChooserRequest = new FileChooserRequestSupport.FileChooserRequest(filePathCallback, acceptType, isMultiple);
+        activeFileChooserRequest = new FileChooserRequestSupport.FileChooserRequest(filePathCallback, acceptTypes, isMultiple);
         syncFileChooserPublicFields();
     }
 
@@ -4126,45 +4121,10 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
         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);
-
-        // 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 = "*/*";
-                }
-            }
-        }
+        java.util.LinkedHashSet<String> mimeTypes = FileChooserAcceptSupport.normalizeAcceptTypes(request.acceptTypes);
+        Intent intent = FileChooserAcceptSupport.createFileChooserIntent(request.acceptTypes, request.multiple);
 
-        Log.d("InAppBrowser", "File picker using MIME type: " + acceptType);
-        intent.setType(acceptType);
-        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, isMultiple);
+        Log.d("InAppBrowser", "File picker using action: " + intent.getAction() + ", MIME types: " + mimeTypes);
 
         try {
             if (activity instanceof androidx.activity.ComponentActivity) {
@@ -4207,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;

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.1"
+    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.1",
+  "version": "8.15.2",
   "description": "Capacitor plugin in app browser",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",