@capgo/camera-preview 8.11.4 → 8.11.6

package/android/build.gradle

@@ -40,6 +40,9 @@ android {
     lintOptions {
         abortOnError = false
     }
+    testOptions {
+        unitTests.includeAndroidResources = true
+    }
 }
 
 repositories {
@@ -69,6 +72,8 @@ dependencies {
     implementation 'com.google.android.gms:play-services-mlkit-barcode-scanning:18.3.1'
 
     testImplementation "junit:junit:$junitVersion"
+    testImplementation 'org.robolectric:robolectric:4.14.1'
+    testImplementation 'androidx.test:core:1.6.1'
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
 }

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java

@@ -29,7 +29,6 @@ import android.view.ViewGroup;
 import android.webkit.WebView;
 import androidx.annotation.RequiresPermission;
 import androidx.appcompat.app.AlertDialog;
-import androidx.core.app.ActivityCompat;
 import androidx.core.graphics.Insets;
 import androidx.core.view.ViewCompat;
 import androidx.core.view.WindowInsetsCompat;
@@ -456,10 +455,13 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         final boolean withExifLocation = Boolean.TRUE.equals(call.getBoolean("withExifLocation", false));
 
         if (withExifLocation) {
-            if (getPermissionState(CAMERA_WITH_LOCATION_PERMISSION_ALIAS) != PermissionState.GRANTED) {
+            if (LocationPermissionHelper.canCaptureWithExifLocation(getContext())) {
+                getLocationAndCapture(call);
+            } else if (getPermissionState(CAMERA_WITH_LOCATION_PERMISSION_ALIAS) != PermissionState.GRANTED) {
                 requestPermissionForAlias(CAMERA_WITH_LOCATION_PERMISSION_ALIAS, call, "captureWithLocationPermission");
             } else {
-                getLocationAndCapture(call);
+                Logger.warn("Location permission unavailable. Capturing photo without location data.");
+                captureWithoutLocation(call);
             }
         } else {
             captureWithoutLocation(call);
@@ -469,35 +471,40 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
     @SuppressLint("MissingPermission")
     @PermissionCallback
     private void captureWithLocationPermission(PluginCall call) {
-        if (getPermissionState(CAMERA_WITH_LOCATION_PERMISSION_ALIAS) == PermissionState.GRANTED) {
-            if (
-                ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.ACCESS_FINE_LOCATION) !=
-                    PackageManager.PERMISSION_GRANTED ||
-                ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.ACCESS_COARSE_LOCATION) !=
-                PackageManager.PERMISSION_GRANTED
-            ) {
-                return;
-            }
+        if (LocationPermissionHelper.canCaptureWithExifLocation(getContext())) {
             getLocationAndCapture(call);
         } else {
-            Logger.warn("Location permission denied. Capturing photo without location data.");
+            Logger.warn("Location permission denied or unavailable. Capturing photo without location data.");
             captureWithoutLocation(call);
         }
     }
 
-    @RequiresPermission(allOf = { Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION })
+    @RequiresPermission(anyOf = { Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION })
     private void getLocationAndCapture(PluginCall call) {
+        if (getActivity() == null) {
+            Logger.warn("Activity unavailable for location lookup. Capturing photo without location data.");
+            captureWithoutLocation(call);
+            return;
+        }
+
         if (fusedLocationClient == null) {
             fusedLocationClient = LocationServices.getFusedLocationProviderClient(getContext());
         }
         fusedLocationClient
             .getLastLocation()
-            .addOnSuccessListener(getActivity(), (location) -> {
-                lastLocation = location;
-                proceedWithCapture(call, lastLocation);
-            })
-            .addOnFailureListener((e) -> {
-                Logger.error("Failed to get location: " + e.getMessage());
+            .addOnCompleteListener((task) -> {
+                if (task.isCanceled()) {
+                    Logger.warn("Location lookup cancelled. Capturing photo without location data.");
+                    proceedWithCapture(call, null);
+                    return;
+                }
+                if (task.isSuccessful()) {
+                    lastLocation = task.getResult();
+                    proceedWithCapture(call, lastLocation);
+                    return;
+                }
+                Exception error = task.getException();
+                Logger.error("Failed to get location: " + (error != null ? error.getMessage() : "unknown error"));
                 proceedWithCapture(call, null);
             });
     }

package/android/src/main/java/app/capgo/capacitor/camera/preview/LocationPermissionHelper.java

@@ -0,0 +1,32 @@
+package app.capgo.capacitor.camera.preview;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import androidx.core.app.ActivityCompat;
+
+/**
+ * Runtime location permission checks for EXIF capture.
+ * <p>
+ * Capacitor's cached {@link PermissionState} can diverge from the OS grant state; always
+ * verify both before requesting location and before settling a capture call.
+ */
+public final class LocationPermissionHelper {
+
+    private LocationPermissionHelper() {}
+
+    public static boolean hasRuntimeLocationPermissions(Context context) {
+        return (
+            ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED ||
+            ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
+        );
+    }
+
+    public static boolean canCaptureWithExifLocation(Context context) {
+        return canCaptureWithExifLocation(hasRuntimeLocationPermissions(context));
+    }
+
+    static boolean canCaptureWithExifLocation(boolean hasRuntimeLocationPermissions) {
+        return hasRuntimeLocationPermissions;
+    }
+}

package/android/src/test/java/app/capgo/capacitor/camera/preview/LocationPermissionHelperContextTest.java

@@ -0,0 +1,38 @@
+package app.capgo.capacitor.camera.preview;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.Manifest;
+import android.app.Application;
+import androidx.test.core.app.ApplicationProvider;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 31)
+public class LocationPermissionHelperContextTest {
+
+    @Test
+    public void canCaptureWithExifLocationContextOverloadAllowsFineOnly() {
+        Application application = (Application) ApplicationProvider.getApplicationContext();
+        shadowOf(application).grantPermissions(Manifest.permission.ACCESS_FINE_LOCATION);
+        assertTrue(LocationPermissionHelper.canCaptureWithExifLocation(application));
+    }
+
+    @Test
+    public void canCaptureWithExifLocationContextOverloadAllowsCoarseOnly() {
+        Application application = (Application) ApplicationProvider.getApplicationContext();
+        shadowOf(application).grantPermissions(Manifest.permission.ACCESS_COARSE_LOCATION);
+        assertTrue(LocationPermissionHelper.canCaptureWithExifLocation(application));
+    }
+
+    @Test
+    public void canCaptureWithExifLocationContextOverloadDeniesWhenNeitherGranted() {
+        Application application = (Application) ApplicationProvider.getApplicationContext();
+        assertFalse(LocationPermissionHelper.canCaptureWithExifLocation(application));
+    }
+}

package/android/src/test/java/app/capgo/capacitor/camera/preview/LocationPermissionHelperTest.java

@@ -0,0 +1,25 @@
+package app.capgo.capacitor.camera.preview;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class LocationPermissionHelperTest {
+
+    @Test
+    public void canCaptureWithExifLocationUsesRuntimePermissionOnly() {
+        assertTrue(LocationPermissionHelper.canCaptureWithExifLocation(true));
+        assertFalse(LocationPermissionHelper.canCaptureWithExifLocation(false));
+    }
+
+    @Test
+    public void runtimeAccessAllowsExifCaptureRegardlessOfCapacitorCache() {
+        assertTrue(LocationPermissionHelper.canCaptureWithExifLocation(true));
+    }
+
+    @Test
+    public void missingRuntimePermissionsFallsBackToGpsLessCapture() {
+        assertFalse(LocationPermissionHelper.canCaptureWithExifLocation(false));
+    }
+}

package/dist/esm/web.js

@@ -67,7 +67,7 @@ export class CameraPreviewWeb extends WebPlugin {
                 try {
                     stream === null || stream === void 0 ? void 0 : stream.getTracks().forEach((t) => t.stop());
                 }
-                catch (_e) {
+                catch (_c) {
                     /* no-op */
                 }
             }
@@ -177,16 +177,13 @@ export class CameraPreviewWeb extends WebPlugin {
         const leftInset = parseInset(styles.paddingLeft);
         const rightInset = parseInset(styles.paddingRight);
         probe.remove();
-        let top = 0;
-        if (orientation === 1) {
-            top = topInset;
-        }
-        else if (orientation === 2) {
-            top = leftInset > 0 ? leftInset : rightInset;
-        }
-        else {
-            top = Math.max(topInset, leftInset, rightInset);
-        }
+        const top = orientation === 1
+            ? topInset
+            : orientation === 2
+                ? leftInset > 0
+                    ? leftInset
+                    : rightInset
+                : Math.max(topInset, leftInset, rightInset);
         return { orientation, top };
     }
     async getZoomButtonValues() {
@@ -382,7 +379,7 @@ export class CameraPreviewWeb extends WebPlugin {
                     }
                     this.videoElement.style.setProperty('top', `${y}px`, 'important');
                     // Force a style recalculation
-                    this.videoElement.offsetHeight;
+                    void this.videoElement.offsetHeight;
                     console.log('Positioning video:', {
                         positioning,
                         viewportHeight: window.innerHeight,
@@ -873,7 +870,9 @@ export class CameraPreviewWeb extends WebPlugin {
             await video.play();
         }
         catch (error) {
-            throw new Error(`Failed to flip camera: ${error}`);
+            const err = new Error(`Failed to flip camera: ${String(error)}`);
+            err.cause = error;
+            throw err;
         }
     }
     async setOpacity(_options) {
@@ -1064,7 +1063,9 @@ export class CameraPreviewWeb extends WebPlugin {
             });
         }
         catch (error) {
-            throw new Error(`Failed to set zoom: ${error}`);
+            const err = new Error(`Failed to set zoom: ${String(error)}`);
+            err.cause = error;
+            throw err;
         }
     }
     async getFlashMode() {
@@ -1110,7 +1111,9 @@ export class CameraPreviewWeb extends WebPlugin {
             await video.play();
         }
         catch (error) {
-            throw new Error(`Failed to swap to device ${options.deviceId}: ${error}`);
+            const err = new Error(`Failed to swap to device ${options.deviceId}: ${String(error)}`);
+            err.cause = error;
+            throw err;
         }
     }
     async getAspectRatio() {