@capgo/camera-preview 7.4.0-beta.15 → 7.4.0-beta.17

package/README.md

@@ -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,6 +9,7 @@ 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;
@@ -171,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
@@ -574,6 +576,41 @@ 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;
@@ -588,7 +625,13 @@ public class CameraPreview
           : getBridge().getWebView().getHeight();
         computedHeight -= (int) (paddingBottom * pixelRatio);
 
-        Log.d("CameraPreview", "Positioning logic - x: " + x + ", y: " + y);
+        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
@@ -617,20 +660,51 @@ public class CameraPreview
         }
 
         if (y == -1) {
-          // Center vertically using full screen height
-          int screenHeight = metrics.heightPixels;
-          computedY = (screenHeight - computedHeight) / 2;
-          Log.d(
-            "CameraPreview",
-            "Centering vertically: screenHeight=" +
-            screenHeight +
-            ", computedHeight=" +
-            computedHeight +
-            ", computedY=" +
-            computedY
-          );
+          // 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: " +
@@ -638,10 +712,15 @@ public class CameraPreview
             " * " +
             pixelRatio +
             " = " +
-            computedY
+            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
@@ -776,18 +855,16 @@ public class CameraPreview
         .getDisplayMetrics();
       float pixelRatio = metrics.density;
 
-      // Check if edge-to-edge mode is active by looking at WebView insets
-      // If the WebView has a top margin, it means edge-to-edge is active
-      // and JavaScript positions are relative to WebView content area
+      // 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;
-      WebView webView = getBridge().getWebView();
-      if (
-        webView != null &&
-        webView.getLayoutParams() instanceof ViewGroup.MarginLayoutParams
-      ) {
-        webViewTopInset =
-          ((ViewGroup.MarginLayoutParams) webView.getLayoutParams()).topMargin;
+      if (webView != null) {
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        webViewTopInset = location[1];
         isEdgeToEdgeActive = webViewTopInset > 0;
       }
 
@@ -972,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;

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

@@ -360,6 +360,14 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       Log.d(TAG, "setupPreviewView: Setting grid mode to: " + currentGridMode);
       gridOverlayView.setGridMode(currentGridMode);
     });
+    
+    // Add a layout listener to update grid bounds when preview view changes size
+    previewView.addOnLayoutChangeListener((v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom) -> {
+      if (left != oldLeft || top != oldTop || right != oldRight || bottom != oldBottom) {
+        Log.d(TAG, "PreviewView layout changed, updating grid bounds");
+        updateGridOverlayBounds();
+      }
+    });
 
     ViewGroup parent = (ViewGroup) webView.getParent();
     if (parent != null) {
@@ -480,6 +488,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
             if (height != oldHeight) {
               int screenHeight = metrics.heightPixels;
+              // Always center based on full screen height
               y = (screenHeight - height) / 2;
               Log.d(
                 TAG,
@@ -516,27 +525,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       height
     );
 
-    // Only add insets for positioning coordinates, not for full-screen sizes or centered content
-    int webViewTopInset = getWebViewTopInset();
-    int webViewLeftInset = getWebViewLeftInset();
-
-    // Don't add insets if centered or full-screen
-    if (sessionConfig.isCentered() || (x == 0 && y == 0)) {
-      layoutParams.leftMargin = x;
-      layoutParams.topMargin = y;
-      Log.d(
-        TAG,
-        "calculatePreviewLayoutParams: Centered/Full-screen mode - keeping position without insets. isCentered=" +
-        sessionConfig.isCentered()
-      );
-    } else {
-      layoutParams.leftMargin = x + webViewLeftInset;
-      layoutParams.topMargin = y + webViewTopInset;
-      Log.d(
-        TAG,
-        "calculatePreviewLayoutParams: Positioned mode - applying insets"
-      );
-    }
+    // The X and Y positions passed from CameraPreview already include webView insets
+    // when edge-to-edge is active, so we don't need to add them again here
+    layoutParams.leftMargin = x;
+    layoutParams.topMargin = y;
 
     Log.d(
       TAG,
@@ -562,18 +554,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       " height:" +
       height
     );
-    Log.d(
-      TAG,
-      "calculatePreviewLayoutParams: Final margins - leftMargin:" +
-      layoutParams.leftMargin +
-      " topMargin:" +
-      layoutParams.topMargin +
-      " (WebView insets: left=" +
-      webViewLeftInset +
-      ", top=" +
-      webViewTopInset +
-      ")"
-    );
     return layoutParams;
   }
 
@@ -766,6 +746,9 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
               actualHeight
             );
 
+            // Update grid overlay bounds after camera is started
+            updateGridOverlayBounds();
+
             listener.onCameraStarted(
               actualWidth,
               actualHeight,
@@ -852,9 +835,18 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     final boolean saveToGallery,
     Integer width,
     Integer height,
+    String aspectRatio,
     Location location
   ) {
-    Log.d(TAG, "capturePhoto: Starting photo capture with quality: " + quality);
+    Log.d(TAG, "capturePhoto: Starting photo capture with quality: " + quality + ", aspectRatio: " + aspectRatio);
+
+    // Check for conflicting parameters
+    if (aspectRatio != null && (width != null || height != null)) {
+      if (listener != null) {
+        listener.onPictureTakenError("Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start.");
+      }
+      return;
+    }
 
     if (imageCapture == null) {
       if (listener != null) {
@@ -902,7 +894,63 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
             JSONObject exifData = getExifData(exifInterface);
 
-            if (width != null && height != null) {
+            // Handle aspect ratio if no width/height specified
+            if (width == null && height == null && aspectRatio != null && !aspectRatio.isEmpty()) {
+              // Get the original image dimensions
+              Bitmap originalBitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+              int originalWidth = originalBitmap.getWidth();
+              int originalHeight = originalBitmap.getHeight();
+              
+              // Parse aspect ratio
+              String[] ratios = aspectRatio.split(":");
+              if (ratios.length == 2) {
+                try {
+                  float widthRatio = Float.parseFloat(ratios[0]);
+                  float heightRatio = Float.parseFloat(ratios[1]);
+                  
+                  // For capture in portrait orientation, swap the aspect ratio (16:9 becomes 9:16)
+                  boolean isPortrait = originalHeight > originalWidth;
+                  float targetAspectRatio = isPortrait ? heightRatio / widthRatio : widthRatio / heightRatio;
+                  float originalAspectRatio = (float) originalWidth / originalHeight;
+                  
+                  int targetWidth, targetHeight;
+                  
+                  if (originalAspectRatio > targetAspectRatio) {
+                    // Original is wider than target - fit by height
+                    targetHeight = originalHeight;
+                    targetWidth = (int) (targetHeight * targetAspectRatio);
+                  } else {
+                    // Original is taller than target - fit by width
+                    targetWidth = originalWidth;
+                    targetHeight = (int) (targetWidth / targetAspectRatio);
+                  }
+                  
+                  // Center crop the image
+                  int xOffset = (originalWidth - targetWidth) / 2;
+                  int yOffset = (originalHeight - targetHeight) / 2;
+                  
+                  Bitmap croppedBitmap = Bitmap.createBitmap(
+                    originalBitmap,
+                    xOffset,
+                    yOffset,
+                    targetWidth,
+                    targetHeight
+                  );
+                  
+                  ByteArrayOutputStream stream = new ByteArrayOutputStream();
+                  croppedBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream);
+                  bytes = stream.toByteArray();
+                  
+                  // Write EXIF data back to cropped image
+                  bytes = writeExifToImageBytes(bytes, exifInterface);
+                  
+                  originalBitmap.recycle();
+                  croppedBitmap.recycle();
+                } catch (NumberFormatException e) {
+                  Log.e(TAG, "Invalid aspect ratio format: " + aspectRatio, e);
+                }
+              }
+            } else if (width != null && height != null) {
               Bitmap bitmap = BitmapFactory.decodeByteArray(
                 bytes,
                 0,
@@ -1543,6 +1591,12 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       throw new Exception("Preview view not initialized");
     }
 
+    // Validate that coordinates are within bounds (0-1 range)
+    if (x < 0f || x > 1f || y < 0f || y > 1f) {
+      Log.w(TAG, "setFocus: Coordinates out of bounds - x: " + x + ", y: " + y);
+      throw new Exception("Focus coordinates must be between 0 and 1");
+    }
+
     // Cancel any ongoing focus operation
     if (currentFocusFuture != null && !currentFocusFuture.isDone()) {
       Log.d(TAG, "setFocus: Cancelling previous focus operation");
@@ -1551,16 +1605,18 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     int viewWidth = previewView.getWidth();
     int viewHeight = previewView.getHeight();
-    float indicatorX = x * viewWidth;
-    float indicatorY = y * viewHeight;
-    showFocusIndicator(indicatorX, indicatorY);
-
+    
     if (viewWidth <= 0 || viewHeight <= 0) {
       throw new Exception(
         "Preview view has invalid dimensions: " + viewWidth + "x" + viewHeight
       );
     }
 
+    // Only show focus indicator after validation passes
+    float indicatorX = x * viewWidth;
+    float indicatorY = y * viewHeight;
+    showFocusIndicator(indicatorX, indicatorY);
+
     // Create MeteringPoint using the preview view
     MeteringPointFactory factory = previewView.getMeteringPointFactory();
     MeteringPoint point = factory.createPoint(x * viewWidth, y * viewHeight);
@@ -2576,19 +2632,30 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
             // Wait for camera rebinding to complete, then call callback
             if (callback != null) {
-              previewContainer.post(() -> previewContainer.post(callback));
+              previewContainer.post(() -> {
+                updateGridOverlayBounds();
+                previewContainer.post(callback);
+              });
+            } else {
+              previewContainer.post(() -> updateGridOverlayBounds());
             }
           } else {
             // No camera rebinding needed, wait for layout to complete then call callback
-            if (callback != null) {
-              previewContainer.post(callback);
-            }
+            previewContainer.post(() -> {
+              updateGridOverlayBounds();
+              if (callback != null) {
+                callback.run();
+              }
+            });
           }
         } else {
           // No sessionConfig, just wait for layout then call callback
-          if (callback != null) {
-            previewContainer.post(callback);
-          }
+          previewContainer.post(() -> {
+            updateGridOverlayBounds();
+            if (callback != null) {
+              callback.run();
+            }
+          });
         }
       } else {
         Log.w(
@@ -2727,6 +2794,9 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           finalY +
           ")"
         );
+        
+        // Update grid overlay bounds after aspect ratio change
+        previewContainer.post(() -> updateGridOverlayBounds());
       }
     } catch (NumberFormatException e) {
       Log.e(TAG, "Invalid aspect ratio format: " + aspectRatio, e);
@@ -2736,10 +2806,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   private int getWebViewTopInset() {
     try {
       if (webView != null) {
-        ViewGroup.LayoutParams layoutParams = webView.getLayoutParams();
-        if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
-          return ((ViewGroup.MarginLayoutParams) layoutParams).topMargin;
-        }
+        // Get the actual WebView position on screen
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        return location[1]; // Y position is the top inset
       }
     } catch (Exception e) {
       Log.w(TAG, "Failed to get WebView top inset", e);
@@ -2750,10 +2820,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   private int getWebViewLeftInset() {
     try {
       if (webView != null) {
-        ViewGroup.LayoutParams layoutParams = webView.getLayoutParams();
-        if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
-          return ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
-        }
+        // Get the actual WebView position on screen for consistency
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        return location[0]; // X position is the left inset
       }
     } catch (Exception e) {
       Log.w(TAG, "Failed to get WebView left inset", e);
@@ -2769,33 +2839,48 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       return new int[] { 0, 0, 0, 0 }; // x, y, width, height
     }
 
-    ViewGroup.LayoutParams layoutParams = previewContainer.getLayoutParams();
-    int x = 0, y = 0, width = 0, height = 0;
+    // Get actual camera preview bounds (accounts for letterboxing/pillarboxing)
+    int actualX = getPreviewX();
+    int actualY = getPreviewY();
+    int actualWidth = getPreviewWidth();
+    int actualHeight = getPreviewHeight();
 
-    if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
-      ViewGroup.MarginLayoutParams params =
-        (ViewGroup.MarginLayoutParams) layoutParams;
+    // Convert to logical pixels for JavaScript
+    DisplayMetrics metrics = context.getResources().getDisplayMetrics();
+    float pixelRatio = metrics.density;
 
-      // Remove insets to get original coordinates in DP
-      DisplayMetrics metrics = context.getResources().getDisplayMetrics();
-      float pixelRatio = metrics.density;
+    // Remove WebView insets from coordinates
+    int webViewTopInset = getWebViewTopInset();
+    int webViewLeftInset = getWebViewLeftInset();
 
-      int webViewTopInset = getWebViewTopInset();
-      int webViewLeftInset = getWebViewLeftInset();
+    int x = Math.max(
+      0,
+      (int) ((actualX - webViewLeftInset) / pixelRatio)
+    );
+    int y = Math.max(
+      0,
+      (int) ((actualY - webViewTopInset) / pixelRatio)
+    );
+    int width = (int) (actualWidth / pixelRatio);
+    int height = (int) (actualHeight / pixelRatio);
 
-      x = Math.max(
-        0,
-        (int) ((params.leftMargin - webViewLeftInset) / pixelRatio)
-      );
-      y = Math.max(
-        0,
-        (int) ((params.topMargin - webViewTopInset) / pixelRatio)
+    return new int[] { x, y, width, height };
+  }
+
+  private void updateGridOverlayBounds() {
+    if (gridOverlayView != null && previewView != null) {
+      // Get the actual camera bounds
+      Rect cameraBounds = getActualCameraBounds();
+      
+      // Update the grid overlay with the camera bounds
+      gridOverlayView.setCameraBounds(cameraBounds);
+      
+      Log.d(
+        TAG,
+        "updateGridOverlayBounds: Updated grid bounds to " +
+        cameraBounds.toString()
       );
-      width = (int) (params.width / pixelRatio);
-      height = (int) (params.height / pixelRatio);
     }
-
-    return new int[] { x, y, width, height };
   }
 
   private void triggerAutoFocus() {

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

@@ -3,6 +3,7 @@ package com.ahm.capacitor.camera.preview;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Paint;
+import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.View;
 
@@ -10,6 +11,7 @@ public class GridOverlayView extends View {
 
   private Paint gridPaint;
   private String gridMode = "none";
+  private Rect cameraBounds = null;
 
   public GridOverlayView(Context context) {
     super(context);
@@ -38,6 +40,11 @@ public class GridOverlayView extends View {
     gridPaint.setAntiAlias(true);
   }
 
+  public void setCameraBounds(Rect bounds) {
+    this.cameraBounds = bounds;
+    invalidate();
+  }
+
   public void setGridMode(String mode) {
     String previousMode = this.gridMode;
     this.gridMode = mode != null ? mode : "none";
@@ -62,34 +69,44 @@ public class GridOverlayView extends View {
       return;
     }
 
+    // Use camera bounds if available, otherwise use full view bounds
+    int left = 0;
+    int top = 0;
     int width = getWidth();
     int height = getHeight();
 
+    if (cameraBounds != null) {
+      left = cameraBounds.left;
+      top = cameraBounds.top;
+      width = cameraBounds.width();
+      height = cameraBounds.height();
+    }
+
     if (width <= 0 || height <= 0) {
       return;
     }
 
     if ("3x3".equals(gridMode)) {
-      drawGrid(canvas, width, height, 3);
+      drawGrid(canvas, left, top, width, height, 3);
     } else if ("4x4".equals(gridMode)) {
-      drawGrid(canvas, width, height, 4);
+      drawGrid(canvas, left, top, width, height, 4);
     }
   }
 
-  private void drawGrid(Canvas canvas, int width, int height, int divisions) {
+  private void drawGrid(Canvas canvas, int left, int top, int width, int height, int divisions) {
     float stepX = (float) width / divisions;
     float stepY = (float) height / divisions;
 
     // Draw vertical lines
     for (int i = 1; i < divisions; i++) {
-      float x = i * stepX;
-      canvas.drawLine(x, 0, x, height, gridPaint);
+      float x = left + (i * stepX);
+      canvas.drawLine(x, top, x, top + height, gridPaint);
     }
 
     // Draw horizontal lines
     for (int i = 1; i < divisions; i++) {
-      float y = i * stepY;
-      canvas.drawLine(0, y, width, y, gridPaint);
+      float y = top + (i * stepY);
+      canvas.drawLine(left, y, left + width, y, gridPaint);
     }
   }
 }