@capgo/camera-preview 7.4.0-beta.13 → 7.4.0-beta.16

package/README.md

@@ -562,14 +562,14 @@ Gets the current zoom state, including min/max and current lens info.
 ### setZoom(...)
 
 ```typescript
-setZoom(options: { level: number; ramp?: boolean; }) => Promise<void>
+setZoom(options: { level: number; ramp?: boolean; autoFocus?: boolean; }) => Promise<void>
 ```
 
-Sets the camera's zoom level.
+Sets the zoom level of the camera.
 
-| Param         | Type                                            | Description                                           |
-| ------------- | ----------------------------------------------- | ----------------------------------------------------- |
-| **`options`** | <code>{ level: number; ramp?: boolean; }</code> | - The desired zoom level. `ramp` is currently unused. |
+| Param         | Type                                                                 | Description                                                                         |
+| ------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| **`options`** | <code>{ level: number; ramp?: boolean; autoFocus?: boolean; }</code> | - The desired zoom level. `ramp` is currently unused. `autoFocus` defaults to true. |
 
 **Since:** 7.4.0
 
@@ -652,14 +652,14 @@ Gets the current preview size and position.
 ### setPreviewSize(...)
 
 ```typescript
-setPreviewSize(options: { x: number; y: number; width: number; height: number; }) => Promise<{ width: number; height: number; x: number; y: number; }>
+setPreviewSize(options: { x?: number; y?: number; width: number; height: number; }) => Promise<{ width: number; height: number; x: number; y: number; }>
 ```
 
 Sets the preview size and position.
 
-| Param         | Type                                                                  | Description                      |
-| ------------- | --------------------------------------------------------------------- | -------------------------------- |
-| **`options`** | <code>{ x: number; y: number; width: number; height: number; }</code> | The new position and dimensions. |
+| Param         | Type                                                                    | Description                      |
+| ------------- | ----------------------------------------------------------------------- | -------------------------------- |
+| **`options`** | <code>{ x?: number; y?: number; width: number; height: number; }</code> | The new position and dimensions. |
 
 **Returns:** <code>Promise&lt;{ width: number; height: number; x: number; y: number; }&gt;</code>
 
@@ -707,13 +707,13 @@ Defines the configuration options for starting the camera preview.
 | **`position`**                     | <code>string</code>                           | The camera to use.                                                                                                                                                                                      | <code>"rear"</code> |       |
 | **`storeToFile`**                  | <code>boolean</code>                          | If true, saves the captured image to a file and returns the file path. If false, returns a base64 encoded string.                                                                                       | <code>false</code>  |       |
 | **`disableExifHeaderStripping`**   | <code>boolean</code>                          | If true, prevents the plugin from rotating the image based on EXIF data.                                                                                                                                | <code>false</code>  |       |
-| **`enableHighResolution`**         | <code>boolean</code>                          | If true, enables high-resolution image capture.                                                                                                                                                         | <code>false</code>  |       |
 | **`disableAudio`**                 | <code>boolean</code>                          | If true, disables the audio stream, preventing audio permission requests.                                                                                                                               | <code>true</code>   |       |
 | **`lockAndroidOrientation`**       | <code>boolean</code>                          | If true, locks the device orientation while the camera is active.                                                                                                                                       | <code>false</code>  |       |
 | **`enableOpacity`**                | <code>boolean</code>                          | If true, allows the camera preview's opacity to be changed.                                                                                                                                             | <code>false</code>  |       |
 | **`enableZoom`**                   | <code>boolean</code>                          | If true, enables pinch-to-zoom functionality on the preview.                                                                                                                                            | <code>false</code>  |       |
 | **`enableVideoMode`**              | <code>boolean</code>                          | If true, uses the video-optimized preset for the camera session.                                                                                                                                        | <code>false</code>  |       |
 | **`deviceId`**                     | <code>string</code>                           | The `deviceId` of the camera to use. If provided, `position` is ignored.                                                                                                                                |                     |       |
+| **`initialZoomLevel`**             | <code>number</code>                           | The initial zoom level when starting the camera preview. If the requested zoom level is not available, the native plugin will reject.                                                                   | <code>1.0</code>    | 2.2.0 |
 
 
 #### ExifData
@@ -725,14 +725,15 @@ Represents EXIF data extracted from an image.
 
 Defines the options for capturing a picture.
 
-| Prop                   | Type                                                    | Description                                                                                                                                | Default             | Since |
-| ---------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ------------------- | ----- |
-| **`height`**           | <code>number</code>                                     | The desired height of the picture in pixels. If not provided, the device default is used.                                                  |                     |       |
-| **`width`**            | <code>number</code>                                     | The desired width of the picture in pixels. If not provided, the device default is used.                                                   |                     |       |
-| **`quality`**          | <code>number</code>                                     | The quality of the captured image, from 0 to 100. Does not apply to `png` format.                                                          | <code>85</code>     |       |
-| **`format`**           | <code><a href="#pictureformat">PictureFormat</a></code> | The format of the captured image.                                                                                                          | <code>"jpeg"</code> |       |
-| **`saveToGallery`**    | <code>boolean</code>                                    | If true, the captured image will be saved to the user's gallery.                                                                           | <code>false</code>  | 7.5.0 |
-| **`withExifLocation`** | <code>boolean</code>                                    | If true, the plugin will attempt to add GPS location data to the image's EXIF metadata. This may prompt the user for location permissions. | <code>false</code>  | 7.6.0 |
+| Prop                   | Type                                                    | Description                                                                                                                                                                                                                                              | Default             | Since |
+| ---------------------- | ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | ----- |
+| **`height`**           | <code>number</code>                                     | The desired height of the picture in pixels. If not provided, the device default is used.                                                                                                                                                                |                     |       |
+| **`width`**            | <code>number</code>                                     | The desired width of the picture in pixels. If not provided, the device default is used.                                                                                                                                                                 |                     |       |
+| **`aspectRatio`**      | <code>string</code>                                     | The desired aspect ratio of the captured image (e.g., '4:3', '16:9'). If specified without width/height, captures the largest possible image with this ratio. Cannot be used together with width or height - the capture will be rejected with an error. |                     | 7.7.0 |
+| **`quality`**          | <code>number</code>                                     | The quality of the captured image, from 0 to 100. Does not apply to `png` format.                                                                                                                                                                        | <code>85</code>     |       |
+| **`format`**           | <code><a href="#pictureformat">PictureFormat</a></code> | The format of the captured image.                                                                                                                                                                                                                        | <code>"jpeg"</code> |       |
+| **`saveToGallery`**    | <code>boolean</code>                                    | If true, the captured image will be saved to the user's gallery.                                                                                                                                                                                         | <code>false</code>  | 7.5.0 |
+| **`withExifLocation`** | <code>boolean</code>                                    | If true, the plugin will attempt to add GPS location data to the image's EXIF metadata. This may prompt the user for location permissions.                                                                                                               | <code>false</code>  | 7.6.0 |
 
 
 #### CameraSampleOptions

package/android/src/main/java/com/ahm/capacitor/camera/preview/CameraPreview.java

@@ -9,7 +9,9 @@ import android.location.Location;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.util.Size;
+import android.view.View;
 import android.view.ViewGroup;
+import android.webkit.WebView;
 import com.ahm.capacitor.camera.preview.model.CameraDevice;
 import com.ahm.capacitor.camera.preview.model.CameraSessionConfiguration;
 import com.ahm.capacitor.camera.preview.model.LensInfo;
@@ -170,8 +172,9 @@ public class CameraPreview
     final boolean saveToGallery = call.getBoolean("saveToGallery", false);
     Integer width = call.getInt("width");
     Integer height = call.getInt("height");
+    String aspectRatio = call.getString("aspectRatio");
 
-    cameraXView.capturePhoto(quality, saveToGallery, width, height, location);
+    cameraXView.capturePhoto(quality, saveToGallery, width, height, aspectRatio, location);
   }
 
   @PluginMethod
@@ -277,8 +280,9 @@ public class CameraPreview
       call.reject("level parameter is required");
       return;
     }
+    Boolean autoFocus = call.getBoolean("autoFocus", true);
     try {
-      cameraXView.setZoom(level);
+      cameraXView.setZoom(level, autoFocus);
       call.resolve();
     } catch (Exception e) {
       call.reject("Failed to set zoom: " + e.getMessage());
@@ -297,14 +301,16 @@ public class CameraPreview
       call.reject("x and y parameters are required");
       return;
     }
-    // Ensure values are between 0 and 1
-    float normalizedX = Math.max(0f, Math.min(1f, x));
-    float normalizedY = Math.max(0f, Math.min(1f, y));
+    // Reject if values are outside 0-1 range
+    if (x < 0f || x > 1f || y < 0f || y > 1f) {
+      call.reject("Focus coordinates must be between 0 and 1");
+      return;
+    }
 
     getActivity()
       .runOnUiThread(() -> {
         try {
-          cameraXView.setFocus(normalizedX, normalizedY);
+          cameraXView.setFocus(x, y);
           call.resolve();
         } catch (Exception e) {
           call.reject("Failed to set focus: " + e.getMessage());
@@ -439,8 +445,30 @@ public class CameraPreview
         "back".equals(positionParam))
       ? "back"
       : "front";
-    final int x = call.getInt("x", 0);
-    final int y = call.getInt("y", 0);
+    // Use -1 as default to indicate centering is needed when x/y not provided
+    final Integer xParam = call.getInt("x");
+    final Integer yParam = call.getInt("y");
+    final int x = xParam != null ? xParam : -1;
+    final int y = yParam != null ? yParam : -1;
+
+    Log.d("CameraPreview", "========================");
+    Log.d("CameraPreview", "CAMERA POSITION TRACKING START:");
+    Log.d(
+      "CameraPreview",
+      "1. RAW PARAMS - xParam: " + xParam + ", yParam: " + yParam
+    );
+    Log.d(
+      "CameraPreview",
+      "2. AFTER DEFAULT - x: " +
+      x +
+      " (center=" +
+      (x == -1) +
+      "), y: " +
+      y +
+      " (center=" +
+      (y == -1) +
+      ")"
+    );
     final int width = call.getInt("width", 0);
     final int height = call.getInt("height", 0);
     final int paddingBottom = call.getInt("paddingBottom", 0);
@@ -465,6 +493,7 @@ public class CameraPreview
     );
     final String aspectRatio = call.getString("aspectRatio", "4:3");
     final String gridMode = call.getString("gridMode", "none");
+    final float initialZoomLevel = call.getFloat("initialZoomLevel", 1.0f);
 
     // Check for conflict between aspectRatio and size
     if (
@@ -477,7 +506,7 @@ public class CameraPreview
       return;
     }
 
-    float targetZoom = 1.0f;
+    float targetZoom = initialZoomLevel;
     // Check if the selected device is a physical ultra-wide
     if (originalDeviceId != null) {
       List<CameraDevice> devices = CameraXView.getAvailableDevicesStatic(
@@ -547,11 +576,162 @@ public class CameraPreview
 
         // Calculate pixel ratio
         float pixelRatio = metrics.density;
+        
+        // The key insight: JavaScript coordinates are relative to the WebView's viewport
+        // If the WebView is positioned below the status bar (webViewLocationOnScreen[1] > 0), 
+        // we need to add that offset when placing native views
+        int webViewTopInset = webViewLocationOnScreen[1];
+        boolean isEdgeToEdgeActive = webViewLocationOnScreen[1] > 0;
+        
+        // Log all the positioning information for debugging
+        Log.d("CameraPreview", "WebView Position Debug:");
+        Log.d("CameraPreview", "  - webView.getTop(): " + webViewTop);
+        Log.d("CameraPreview", "  - webView.getLeft(): " + webViewLeft);
+        Log.d("CameraPreview", "  - webView locationInWindow: (" + webViewLocationInWindow[0] + ", " + webViewLocationInWindow[1] + ")");
+        Log.d("CameraPreview", "  - webView locationOnScreen: (" + webViewLocationOnScreen[0] + ", " + webViewLocationOnScreen[1] + ")");
+        Log.d("CameraPreview", "  - parent locationInWindow: (" + parentLocationInWindow[0] + ", " + parentLocationInWindow[1] + ")");
+        Log.d("CameraPreview", "  - parent locationOnScreen: (" + parentLocationOnScreen[0] + ", " + parentLocationOnScreen[1] + ")");
+        
+        // Check if WebView has margins
+        View webView = getBridge().getWebView();
+        ViewGroup.LayoutParams webViewLayoutParams = webView.getLayoutParams();
+        if (webViewLayoutParams instanceof ViewGroup.MarginLayoutParams) {
+          ViewGroup.MarginLayoutParams marginParams = (ViewGroup.MarginLayoutParams) webViewLayoutParams;
+          Log.d("CameraPreview", "  - webView margins: left=" + marginParams.leftMargin + 
+                ", top=" + marginParams.topMargin + 
+                ", right=" + marginParams.rightMargin + 
+                ", bottom=" + marginParams.bottomMargin);
+        }
+        
+        // Check WebView padding
+        Log.d("CameraPreview", "  - webView padding: left=" + webView.getPaddingLeft() + 
+              ", top=" + webView.getPaddingTop() + 
+              ", right=" + webView.getPaddingRight() + 
+              ", bottom=" + webView.getPaddingBottom());
+        
+        Log.d("CameraPreview", "  - Using webViewTopInset: " + webViewTopInset);
+        Log.d("CameraPreview", "  - isEdgeToEdgeActive: " + isEdgeToEdgeActive);
+
+        // Calculate position - center if x or y is -1
+        int computedX;
+        int computedY;
+
+        // Calculate dimensions first
+        int computedWidth = width != 0
+          ? (int) (width * pixelRatio)
+          : getBridge().getWebView().getWidth();
+        int computedHeight = height != 0
+          ? (int) (height * pixelRatio)
+          : getBridge().getWebView().getHeight();
+        computedHeight -= (int) (paddingBottom * pixelRatio);
 
-        // Try using just the pixel ratio without any webview offset for now
-        int computedX = (int) (x * pixelRatio);
-        int computedY = (int) (y * pixelRatio);
+        Log.d("CameraPreview", "========================");
+        Log.d("CameraPreview", "POSITIONING CALCULATIONS:");
+        Log.d("CameraPreview", "1. INPUT - x: " + x + ", y: " + y + ", width: " + width + ", height: " + height);
+        Log.d("CameraPreview", "2. PIXEL RATIO: " + pixelRatio);
+        Log.d("CameraPreview", "3. SCREEN - width: " + metrics.widthPixels + ", height: " + metrics.heightPixels);
+        Log.d("CameraPreview", "4. WEBVIEW - width: " + getBridge().getWebView().getWidth() + ", height: " + getBridge().getWebView().getHeight());
+        Log.d("CameraPreview", "5. COMPUTED DIMENSIONS - width: " + computedWidth + ", height: " + computedHeight);
+
+        if (x == -1) {
+          // Center horizontally
+          int screenWidth = metrics.widthPixels;
+          computedX = (screenWidth - computedWidth) / 2;
+          Log.d(
+            "CameraPreview",
+            "Centering horizontally: screenWidth=" +
+            screenWidth +
+            ", computedWidth=" +
+            computedWidth +
+            ", computedX=" +
+            computedX
+          );
+        } else {
+          computedX = (int) (x * pixelRatio);
+          Log.d(
+            "CameraPreview",
+            "Using provided X position: " +
+            x +
+            " * " +
+            pixelRatio +
+            " = " +
+            computedX
+          );
+        }
+
+        if (y == -1) {
+          // Center vertically
+          if (isEdgeToEdgeActive) {
+            // When WebView is offset from top, center within the available space
+            // The camera should be centered in the full screen, not just the WebView area
+            computedY = (metrics.heightPixels - computedHeight) / 2;
+            Log.d(
+              "CameraPreview",
+              "Centering vertically with WebView offset: screenHeight=" +
+              metrics.heightPixels +
+              ", webViewTop=" +
+              webViewTopInset +
+              ", computedHeight=" +
+              computedHeight +
+              ", computedY=" +
+              computedY
+            );
+          } else {
+            // Normal mode - use full screen height
+            computedY = (metrics.heightPixels - computedHeight) / 2;
+            Log.d(
+              "CameraPreview",
+              "Centering vertically (normal): screenHeight=" +
+              metrics.heightPixels +
+              ", computedHeight=" +
+              computedHeight +
+              ", computedY=" +
+              computedY
+            );
+          }
+        } else {
+          computedY = (int) (y * pixelRatio);
+          // If edge-to-edge is active, JavaScript Y is relative to WebView content area
+          // We need to add the inset to get absolute screen position
+          if (isEdgeToEdgeActive) {
+            computedY += webViewTopInset;
+            Log.d(
+              "CameraPreview",
+              "Edge-to-edge adjustment: Y position " +
+              (int)(y * pixelRatio) +
+              " + inset " +
+              webViewTopInset +
+              " = " +
+              computedY
+            );
+          }
+          Log.d(
+            "CameraPreview",
+            "Using provided Y position: " +
+            y +
+            " * " +
+            pixelRatio +
+            " = " +
+            computedY +
+            (isEdgeToEdgeActive ? " (adjusted for edge-to-edge)" : "")
+          );
+        }
 
+        Log.d(
+          "CameraPreview",
+          "2b. EDGE-TO-EDGE - " + (isEdgeToEdgeActive ? "ACTIVE (inset=" + webViewTopInset + ")" : "INACTIVE")
+        );
+        Log.d(
+          "CameraPreview",
+          "3. COMPUTED POSITION - x=" + computedX + ", y=" + computedY
+        );
+        Log.d(
+          "CameraPreview",
+          "4. COMPUTED SIZE - width=" +
+          computedWidth +
+          ", height=" +
+          computedHeight
+        );
         Log.d("CameraPreview", "=== COORDINATE DEBUG ===");
         Log.d(
           "CameraPreview",
@@ -606,14 +786,11 @@ public class CameraPreview
           computedY +
           ")"
         );
+        Log.d("CameraPreview", "5. IS_CENTERED - " + (x == -1 || y == -1));
         Log.d("CameraPreview", "========================");
-        int computedWidth = width != 0
-          ? (int) (width * pixelRatio)
-          : getBridge().getWebView().getWidth();
-        int computedHeight = height != 0
-          ? (int) (height * pixelRatio)
-          : getBridge().getWebView().getHeight();
-        computedHeight -= (int) (paddingBottom * pixelRatio);
+
+        // Pass along whether we're centering so CameraXView knows not to add insets
+        boolean isCentered = (x == -1 || y == -1);
 
         CameraSessionConfiguration config = new CameraSessionConfiguration(
           finalDeviceId,
@@ -634,6 +811,7 @@ public class CameraPreview
           gridMode
         );
         config.setTargetZoom(finalTargetZoom);
+        config.setCentered(isCentered);
 
         bridge.saveCall(call);
         cameraStartCallbackId = call.getCallbackId();
@@ -677,11 +855,68 @@ public class CameraPreview
         .getDisplayMetrics();
       float pixelRatio = metrics.density;
 
+      // When WebView is offset from the top (e.g., below status bar),
+      // we need to convert between JavaScript coordinates (relative to WebView)
+      // and native coordinates (relative to screen)
+      WebView webView = getBridge().getWebView();
+      int webViewTopInset = 0;
+      boolean isEdgeToEdgeActive = false;
+      if (webView != null) {
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        webViewTopInset = location[1];
+        isEdgeToEdgeActive = webViewTopInset > 0;
+      }
+
+      // Only convert to relative position if edge-to-edge is active
+      int relativeY = isEdgeToEdgeActive ? (y - webViewTopInset) : y;
+
+      Log.d("CameraPreview", "========================");
+      Log.d("CameraPreview", "CAMERA STARTED - POSITION RETURNED:");
+      Log.d(
+        "CameraPreview",
+        "7. RETURNED (pixels) - x=" +
+        x +
+        ", y=" +
+        y +
+        ", width=" +
+        width +
+        ", height=" +
+        height
+      );
+      Log.d(
+        "CameraPreview",
+        "8. EDGE-TO-EDGE - " + (isEdgeToEdgeActive ? "ACTIVE" : "INACTIVE")
+      );
+      Log.d("CameraPreview", "9. WEBVIEW INSET - " + webViewTopInset);
+      Log.d(
+        "CameraPreview",
+        "10. RELATIVE Y - " +
+        relativeY +
+        " (y=" +
+        y +
+        (isEdgeToEdgeActive ? " - inset=" + webViewTopInset : " unchanged") +
+        ")"
+      );
+      Log.d(
+        "CameraPreview",
+        "11. RETURNED (logical) - x=" +
+        (x / pixelRatio) +
+        ", y=" +
+        (relativeY / pixelRatio) +
+        ", width=" +
+        (width / pixelRatio) +
+        ", height=" +
+        (height / pixelRatio)
+      );
+      Log.d("CameraPreview", "12. PIXEL RATIO - " + pixelRatio);
+      Log.d("CameraPreview", "========================");
+
       JSObject result = new JSObject();
       result.put("width", width / pixelRatio);
       result.put("height", height / pixelRatio);
       result.put("x", x / pixelRatio);
-      result.put("y", y / pixelRatio);
+      result.put("y", relativeY / pixelRatio);
       call.resolve(result);
       bridge.releaseCall(call);
       cameraStartCallbackId = null; // Prevent re-use
@@ -814,8 +1049,24 @@ public class CameraPreview
       .getDisplayMetrics();
     float pixelRatio = metrics.density;
 
+    // Check if edge-to-edge mode is active
+    WebView webView = getBridge().getWebView();
+    int webViewTopInset = 0;
+    boolean isEdgeToEdgeActive = false;
+    if (webView != null) {
+      int[] location = new int[2];
+      webView.getLocationOnScreen(location);
+      webViewTopInset = location[1];
+      isEdgeToEdgeActive = webViewTopInset > 0;
+    }
+
     int x = (xParam != null && xParam > 0) ? (int) (xParam * pixelRatio) : 0;
     int y = (yParam != null && yParam > 0) ? (int) (yParam * pixelRatio) : 0;
+    
+    // Add edge-to-edge inset to Y if active
+    if (isEdgeToEdgeActive && y > 0) {
+      y += webViewTopInset;
+    }
     int width = (widthParam != null && widthParam > 0)
       ? (int) (widthParam * pixelRatio)
       : 0;