@capgo/inappbrowser 7.6.4 → 7.6.7

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

@@ -19,6 +19,8 @@ import android.graphics.PorterDuffColorFilter;
 import android.net.Uri;
 import android.net.http.SslError;
 import android.os.Build;
+import android.os.Environment;
+import android.provider.MediaStore;
 import android.text.TextUtils;
 import android.util.Base64;
 import android.util.Log;
@@ -43,6 +45,9 @@ import android.widget.ImageView;
 import android.widget.TextView;
 import android.widget.Toast;
 import android.widget.Toolbar;
+import androidx.activity.result.ActivityResult;
+import androidx.activity.result.contract.ActivityResultContracts;
+import androidx.core.content.FileProvider;
 import androidx.core.graphics.Insets;
 import androidx.core.view.ViewCompat;
 import androidx.core.view.WindowInsetsCompat;
@@ -51,6 +56,7 @@ import com.caverock.androidsvg.SVG;
 import com.caverock.androidsvg.SVGParseException;
 import com.getcapacitor.JSObject;
 import java.io.ByteArrayInputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
@@ -110,6 +116,9 @@ public class WebViewDialog extends Dialog {
   public ValueCallback<Uri> mUploadMessage;
   public ValueCallback<Uri[]> mFilePathCallback;
 
+  // Temporary URI for storing camera capture
+  public Uri tempCameraUri;
+
   public interface PermissionHandler {
     void handleCameraPermissionRequest(PermissionRequest request);
 
@@ -336,21 +345,206 @@ public class WebViewDialog extends Dialog {
           FileChooserParams fileChooserParams
         ) {
           // Get the accept type safely
-          String acceptType = "*/*"; // Default to all file types
+          String acceptType;
           if (
             fileChooserParams.getAcceptTypes() != null &&
             fileChooserParams.getAcceptTypes().length > 0 &&
             !TextUtils.isEmpty(fileChooserParams.getAcceptTypes()[0])
           ) {
             acceptType = fileChooserParams.getAcceptTypes()[0];
+          } else {
+            acceptType = "*/*";
           }
 
+          // DEBUG: Log details about the file chooser request
+          Log.d("InAppBrowser", "onShowFileChooser called");
+          Log.d("InAppBrowser", "Accept type: " + acceptType);
+          Log.d(
+            "InAppBrowser",
+            "Current URL: " +
+            (webView.getUrl() != null ? webView.getUrl() : "null")
+          );
+          Log.d(
+            "InAppBrowser",
+            "Original URL: " +
+            (webView.getOriginalUrl() != null
+                ? webView.getOriginalUrl()
+                : "null")
+          );
+          Log.d(
+            "InAppBrowser",
+            "Has camera permission: " +
+            (activity != null &&
+              activity.checkSelfPermission(
+                android.Manifest.permission.CAMERA
+              ) ==
+              android.content.pm.PackageManager.PERMISSION_GRANTED)
+          );
+
           // Check if the file chooser is already open
           if (mFilePathCallback != null) {
             mFilePathCallback.onReceiveValue(null);
             mFilePathCallback = null;
           }
 
+          mFilePathCallback = filePathCallback;
+
+          // Direct check for capture attribute in URL (fallback method)
+          boolean isCaptureInUrl;
+          String captureMode;
+          String currentUrl = webView.getUrl();
+
+          // Look for capture in URL parameters - sometimes the attribute shows up in URL
+          if (currentUrl != null && currentUrl.contains("capture=")) {
+            isCaptureInUrl = true;
+            captureMode = currentUrl.contains("capture=user")
+              ? "user"
+              : "environment";
+            Log.d("InAppBrowser", "Found capture in URL: " + captureMode);
+          } else {
+            captureMode = null;
+            isCaptureInUrl = false;
+          }
+
+          // For image inputs, try to detect capture attribute using JavaScript
+          if (acceptType.equals("image/*")) {
+            // Check if HTML content contains capture attribute on file inputs (synchronous check)
+            webView.evaluateJavascript(
+              "document.querySelector('input[type=\"file\"][capture]') !== null",
+              hasCaptureValue -> {
+                Log.d(
+                  "InAppBrowser",
+                  "Quick capture check: " + hasCaptureValue
+                );
+                if (Boolean.parseBoolean(hasCaptureValue.replace("\"", ""))) {
+                  Log.d(
+                    "InAppBrowser",
+                    "Found capture attribute in quick check"
+                  );
+                }
+              }
+            );
+
+            // Fixed JavaScript with proper error handling
+            String js =
+              "try {" +
+              "  (function() {" +
+              "    var captureAttr = null;" +
+              "    // Check active element first" +
+              "    if (document.activeElement && " +
+              "        document.activeElement.tagName === 'INPUT' && " +
+              "        document.activeElement.type === 'file') {" +
+              "      if (document.activeElement.hasAttribute('capture')) {" +
+              "        captureAttr = document.activeElement.getAttribute('capture') || 'environment';" +
+              "        return captureAttr;" +
+              "      }" +
+              "    }" +
+              "    // Try to find any input with capture attribute" +
+              "    var inputs = document.querySelectorAll('input[type=\"file\"][capture]');" +
+              "    if (inputs && inputs.length > 0) {" +
+              "      captureAttr = inputs[0].getAttribute('capture') || 'environment';" +
+              "      return captureAttr;" +
+              "    }" +
+              "    // Try to extract from HTML attributes" +
+              "    var allInputs = document.getElementsByTagName('input');" +
+              "    for (var i = 0; i < allInputs.length; i++) {" +
+              "      var input = allInputs[i];" +
+              "      if (input.type === 'file') {" +
+              "        if (input.hasAttribute('capture')) {" +
+              "          captureAttr = input.getAttribute('capture') || 'environment';" +
+              "          return captureAttr;" +
+              "        }" +
+              "        // Look for the accept attribute containing image/* as this might be a camera input" +
+              "        var acceptAttr = input.getAttribute('accept');" +
+              "        if (acceptAttr && acceptAttr.indexOf('image/*') >= 0) {" +
+              "          console.log('Found input with image/* accept');" +
+              "        }" +
+              "      }" +
+              "    }" +
+              "    return '';" +
+              "  })();" +
+              "} catch(e) { console.error('Capture detection error:', e); return ''; }";
+
+            webView.evaluateJavascript(js, value -> {
+              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"));
+                return;
+              }
+
+              // Process JavaScript result
+              if (value != null && value.length() > 2) {
+                // Clean up the value (remove quotes)
+                String captureValue = value.replace("\"", "");
+                Log.d(
+                  "InAppBrowser",
+                  "Found capture attribute: " + captureValue
+                );
+
+                if (!captureValue.isEmpty()) {
+                  activity.runOnUiThread(() ->
+                    launchCamera(captureValue.equals("user"))
+                  );
+                  return;
+                }
+              }
+
+              // Look for hints in the web page source
+              Log.d("InAppBrowser", "Looking for camera hints in page content");
+              webView.evaluateJavascript(
+                "(function() { return document.documentElement.innerHTML; })()",
+                htmlSource -> {
+                  if (htmlSource != null && htmlSource.length() > 10) {
+                    boolean hasCameraOrSelfieKeyword =
+                      htmlSource.contains("capture=") ||
+                      htmlSource.contains("camera") ||
+                      htmlSource.contains("selfie");
+
+                    Log.d(
+                      "InAppBrowser",
+                      "Page contains camera keywords: " +
+                      hasCameraOrSelfieKeyword
+                    );
+
+                    if (
+                      hasCameraOrSelfieKeyword &&
+                      currentUrl != null &&
+                      (currentUrl.contains("selfie") ||
+                        currentUrl.contains("camera") ||
+                        currentUrl.contains("photo"))
+                    ) {
+                      Log.d(
+                        "InAppBrowser",
+                        "URL suggests camera usage, launching camera"
+                      );
+                      activity.runOnUiThread(() ->
+                        launchCamera(currentUrl.contains("selfie"))
+                      );
+                      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
+                  );
+                }
+              );
+            });
+            return true;
+          }
+
+          // For non-image types, use regular file picker
           openFileChooser(
             filePathCallback,
             acceptType,
@@ -359,6 +553,160 @@ public class WebViewDialog extends Dialog {
           return true;
         }
 
+        /**
+         * Launch the camera app for capturing images
+         * @param useFrontCamera true to use front camera, false for back camera
+         */
+        private void launchCamera(boolean useFrontCamera) {
+          Log.d(
+            "InAppBrowser",
+            "Launching camera, front camera: " + useFrontCamera
+          );
+
+          // First check if we have camera permission
+          if (activity != null && permissionHandler != null) {
+            // Create a temporary permission request to check camera permission
+            android.webkit.PermissionRequest tempRequest =
+              new android.webkit.PermissionRequest() {
+                @Override
+                public Uri getOrigin() {
+                  return Uri.parse("file:///android_asset/");
+                }
+
+                @Override
+                public String[] getResources() {
+                  return new String[] {
+                    PermissionRequest.RESOURCE_VIDEO_CAPTURE,
+                  };
+                }
+
+                @Override
+                public void grant(String[] resources) {
+                  // Permission granted, now launch the camera
+                  launchCameraWithPermission(useFrontCamera);
+                }
+
+                @Override
+                public void deny() {
+                  // Permission denied, fall back to file picker
+                  Log.e(
+                    "InAppBrowser",
+                    "Camera permission denied, falling back to file picker"
+                  );
+                  fallbackToFilePicker();
+                }
+              };
+
+            // Request camera permission through the plugin
+            permissionHandler.handleCameraPermissionRequest(tempRequest);
+            return;
+          }
+
+          // If we can't request permission, try launching directly
+          launchCameraWithPermission(useFrontCamera);
+        }
+
+        /**
+         * Launch camera after permission is granted
+         */
+        private void launchCameraWithPermission(boolean useFrontCamera) {
+          try {
+            Intent takePictureIntent = new Intent(
+              MediaStore.ACTION_IMAGE_CAPTURE
+            );
+            if (
+              takePictureIntent.resolveActivity(activity.getPackageManager()) !=
+              null
+            ) {
+              File photoFile = null;
+              try {
+                photoFile = createImageFile();
+              } catch (IOException ex) {
+                Log.e("InAppBrowser", "Error creating image file", ex);
+                fallbackToFilePicker();
+                return;
+              }
+
+              if (photoFile != null) {
+                tempCameraUri = FileProvider.getUriForFile(
+                  activity,
+                  activity.getPackageName() + ".fileprovider",
+                  photoFile
+                );
+                takePictureIntent.putExtra(
+                  MediaStore.EXTRA_OUTPUT,
+                  tempCameraUri
+                );
+
+                if (useFrontCamera) {
+                  takePictureIntent.putExtra(
+                    "android.intent.extras.CAMERA_FACING",
+                    1
+                  );
+                }
+
+                try {
+                  if (activity instanceof androidx.activity.ComponentActivity) {
+                    androidx.activity.ComponentActivity componentActivity =
+                      (androidx.activity.ComponentActivity) activity;
+                    componentActivity
+                      .getActivityResultRegistry()
+                      .register(
+                        "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);
+                          }
+                          mFilePathCallback = null;
+                          tempCameraUri = null;
+                        }
+                      )
+                      .launch(takePictureIntent);
+                  } else {
+                    // Fallback for non-ComponentActivity
+                    activity.startActivityForResult(
+                      takePictureIntent,
+                      FILE_CHOOSER_REQUEST_CODE
+                    );
+                  }
+                } catch (SecurityException e) {
+                  Log.e(
+                    "InAppBrowser",
+                    "Security exception launching camera: " + e.getMessage(),
+                    e
+                  );
+                  fallbackToFilePicker();
+                }
+              } else {
+                Log.e(
+                  "InAppBrowser",
+                  "Failed to create photo URI, falling back to file picker"
+                );
+                fallbackToFilePicker();
+              }
+            }
+          } catch (Exception e) {
+            Log.e("InAppBrowser", "Camera launch failed: " + e.getMessage(), e);
+            fallbackToFilePicker();
+          }
+        }
+
+        /**
+         * Fall back to file picker when camera launch fails
+         */
+        private void fallbackToFilePicker() {
+          if (mFilePathCallback != null) {
+            openFileChooser(mFilePathCallback, "image/*", false);
+          }
+        }
+
         // Grant permissions for cam
         @Override
         public void onPermissionRequest(final PermissionRequest request) {
@@ -479,11 +827,8 @@ public class WebViewDialog extends Dialog {
       if (
         toolbarView != null &&
         toolbarView.getParent() instanceof
-        com.google.android.material.appbar.AppBarLayout
+        com.google.android.material.appbar.AppBarLayout appBarLayout
       ) {
-        com.google.android.material.appbar.AppBarLayout appBarLayout =
-          (com.google.android.material.appbar.AppBarLayout) toolbarView.getParent();
-
         // Remove elevation to eliminate shadows (only on Android 15+)
         appBarLayout.setElevation(0);
         appBarLayout.setStateListAnimator(null);
@@ -703,7 +1048,7 @@ public class WebViewDialog extends Dialog {
       _options.getPreShowScript() +
       '\n' +
       "};\n" +
-      "preShowFunction().then(() => window.PreShowScriptInterface.success()).catch(err => { console.error('Preshow error', err); window.PreShowScriptInterface.error(JSON.stringify(err, Object.getOwnPropertyNames(err))) })";
+      "preShowFunction().then(() => window.PreShowScriptInterface.success()).catch(err => { console.error('Pre show error', err); window.PreShowScriptInterface.error(JSON.stringify(err, Object.getOwnPropertyNames(err))) })";
 
     Log.i(
       "InjectPreShowScript",
@@ -804,10 +1149,47 @@ public class WebViewDialog extends Dialog {
     intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, isMultiple);
 
     try {
-      activity.startActivityForResult(
-        Intent.createChooser(intent, "Select File"),
-        FILE_CHOOSER_REQUEST_CODE
-      );
+      if (activity instanceof androidx.activity.ComponentActivity) {
+        androidx.activity.ComponentActivity componentActivity =
+          (androidx.activity.ComponentActivity) activity;
+        componentActivity
+          .getActivityResultRegistry()
+          .register(
+            "file_chooser",
+            new androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult(),
+            result -> {
+              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];
+                    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() }
+                    );
+                  }
+                }
+              } else {
+                mFilePathCallback.onReceiveValue(null);
+              }
+              mFilePathCallback = null;
+            }
+          )
+          .launch(Intent.createChooser(intent, "Select File"));
+      } else {
+        // Fallback for non-ComponentActivity
+        activity.startActivityForResult(
+          Intent.createChooser(intent, "Select File"),
+          FILE_CHOOSER_REQUEST_CODE
+        );
+      }
     } catch (ActivityNotFoundException e) {
       // If no app can handle the specific MIME type, try with a more generic one
       Log.e(
@@ -816,10 +1198,47 @@ public class WebViewDialog extends Dialog {
       );
       intent.setType("*/*");
       try {
-        activity.startActivityForResult(
-          Intent.createChooser(intent, "Select File"),
-          FILE_CHOOSER_REQUEST_CODE
-        );
+        if (activity instanceof androidx.activity.ComponentActivity) {
+          androidx.activity.ComponentActivity componentActivity =
+            (androidx.activity.ComponentActivity) activity;
+          componentActivity
+            .getActivityResultRegistry()
+            .register(
+              "file_chooser",
+              new androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult(),
+              result -> {
+                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];
+                      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() }
+                      );
+                    }
+                  }
+                } else {
+                  mFilePathCallback.onReceiveValue(null);
+                }
+                mFilePathCallback = null;
+              }
+            )
+            .launch(Intent.createChooser(intent, "Select File"));
+        } else {
+          // Fallback for non-ComponentActivity
+          activity.startActivityForResult(
+            Intent.createChooser(intent, "Select File"),
+            FILE_CHOOSER_REQUEST_CODE
+          );
+        }
       } catch (ActivityNotFoundException ex) {
         // If still failing, report error
         Log.e("InAppBrowser", "No app can handle file picker", ex);
@@ -1191,15 +1610,6 @@ public class WebViewDialog extends Dialog {
               }
             }
 
-            if (inputStream == null) {
-              Log.e(
-                "InAppBrowser",
-                "Failed to load SVG icon: " + buttonNearDone.getIcon()
-              );
-              buttonNearDoneView.setVisibility(View.GONE);
-              return;
-            }
-
             // Parse and render SVG
             SVG svg = SVG.getFromInputStream(inputStream);
             if (svg == null) {
@@ -1880,6 +2290,18 @@ public class WebViewDialog extends Dialog {
   @Override
   public void dismiss() {
     if (_webView != null) {
+      // Reset file inputs to prevent WebView from caching them
+      _webView.evaluateJavascript(
+        "(function() {" +
+        "  var inputs = document.querySelectorAll('input[type=\"file\"]');" +
+        "  for (var i = 0; i < inputs.length; i++) {" +
+        "    inputs[i].value = '';" +
+        "  }" +
+        "  return true;" +
+        "})();",
+        null
+      );
+
       _webView.loadUrl("about:blank");
       _webView.onPause();
       _webView.removeAllViews();
@@ -1977,25 +2399,92 @@ public class WebViewDialog extends Dialog {
 
     // This script adds minimal fixes for date inputs to use Material Design
     String script =
-      "(function() {\n" +
-      "  // Find all date inputs\n" +
-      "  const dateInputs = document.querySelectorAll('input[type=\"date\"]');\n" +
-      "  dateInputs.forEach(input => {\n" +
-      "    // Ensure change events propagate correctly\n" +
-      "    let lastValue = input.value;\n" +
-      "    input.addEventListener('change', () => {\n" +
-      "      if (input.value !== lastValue) {\n" +
-      "        lastValue = input.value;\n" +
-      "        // Dispatch an input event to ensure frameworks detect the change\n" +
-      "        input.dispatchEvent(new Event('input', { bubbles: true }));\n" +
-      "      }\n" +
-      "    });\n" +
-      "  });\n" +
-      "})();";
+      """
+      (function() {
+        // Find all date inputs
+        const dateInputs = document.querySelectorAll('input[type="date"]');
+        dateInputs.forEach(input => {
+          // Ensure change events propagate correctly
+          let lastValue = input.value;
+          input.addEventListener('change', () => {
+            if (input.value !== lastValue) {
+              lastValue = input.value;
+              // Dispatch an input event to ensure frameworks detect the change
+              input.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+          });
+        });
+      })();""";
 
     // Execute the script in the WebView
     _webView.post(() -> _webView.evaluateJavascript(script, null));
 
     Log.d("InAppBrowser", "Applied minimal date picker fixes");
   }
+
+  /**
+   * Creates a temporary URI for storing camera capture
+   * @return URI for the temporary file or null if creation failed
+   */
+  private Uri createTempImageUri() {
+    try {
+      String fileName = "capture_" + System.currentTimeMillis() + ".jpg";
+      java.io.File cacheDir = _context.getCacheDir();
+
+      // Make sure cache directory exists
+      if (!cacheDir.exists() && !cacheDir.mkdirs()) {
+        return null;
+      }
+
+      // Create temporary file
+      java.io.File tempFile = new java.io.File(cacheDir, fileName);
+      if (!tempFile.createNewFile()) {
+        return null;
+      }
+
+      // Get content URI through FileProvider
+      try {
+        return androidx.core.content.FileProvider.getUriForFile(
+          _context,
+          _context.getPackageName() + ".fileprovider",
+          tempFile
+        );
+      } catch (IllegalArgumentException e) {
+        // Try using external storage as fallback
+        java.io.File externalCacheDir = _context.getExternalCacheDir();
+        if (externalCacheDir != null) {
+          tempFile = new java.io.File(externalCacheDir, fileName);
+          final boolean newFile = tempFile.createNewFile();
+          if (!newFile) {
+            Log.d("InAppBrowser", "Error creating new file");
+          }
+          return androidx.core.content.FileProvider.getUriForFile(
+            _context,
+            _context.getPackageName() + ".fileprovider",
+            tempFile
+          );
+        }
+      }
+      return null;
+    } catch (Exception e) {
+      return null;
+    }
+  }
+
+  private File createImageFile() throws IOException {
+    // Create an image file name
+    String timeStamp = new java.text.SimpleDateFormat("yyyyMMdd_HHmmss").format(
+      new java.util.Date()
+    );
+    String imageFileName = "JPEG_" + timeStamp + "_";
+    File storageDir = activity.getExternalFilesDir(
+      Environment.DIRECTORY_PICTURES
+    );
+    File image = File.createTempFile(
+      imageFileName,/* prefix */
+      ".jpg",/* suffix */
+      storageDir/* directory */
+    );
+    return image;
+  }
 }

package/android/src/main/res/xml/file_paths.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- Internal cache for most operations -->
+    <cache-path name="camera_captures" path="." />
+    
+    <!-- External cache for fallback -->
+    <external-cache-path name="external_cache" path="." />
+    
+    <!-- External files for additional compatibility -->
+    <external-files-path name="external_files" path="." />
+    
+    <!-- Allow sharing app-specific files if needed -->
+    <files-path name="app_files" path="." />
+</paths>