@capgo/camera-preview 7.4.0-beta.2 → 7.4.0-beta.21

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

@@ -3,11 +3,22 @@ package com.ahm.capacitor.camera.preview;
 import static android.Manifest.permission.CAMERA;
 import static android.Manifest.permission.RECORD_AUDIO;
 
+import android.Manifest;
 import android.content.pm.ActivityInfo;
+import android.location.Location;
 import android.util.DisplayMetrics;
-import android.util.TypedValue;
+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;
+import com.ahm.capacitor.camera.preview.model.ZoomFactors;
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
+import com.getcapacitor.Logger;
 import com.getcapacitor.PermissionState;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
@@ -15,15 +26,10 @@ import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
 import com.getcapacitor.annotation.Permission;
 import com.getcapacitor.annotation.PermissionCallback;
-import com.ahm.capacitor.camera.preview.model.CameraDevice;
-import com.ahm.capacitor.camera.preview.model.CameraSessionConfiguration;
-import com.ahm.capacitor.camera.preview.model.ZoomFactors;
+import com.google.android.gms.location.FusedLocationProviderClient;
+import com.google.android.gms.location.LocationServices;
 import java.util.List;
 import java.util.Objects;
-import android.util.Size;
-import android.util.Log;
-import com.ahm.capacitor.camera.preview.model.LensInfo;
-
 import org.json.JSONObject;
 
 @CapacitorPlugin(
@@ -37,6 +43,13 @@ import org.json.JSONObject;
       strings = { CAMERA },
       alias = CameraPreview.CAMERA_ONLY_PERMISSION_ALIAS
     ),
+    @Permission(
+      strings = {
+        Manifest.permission.ACCESS_COARSE_LOCATION,
+        Manifest.permission.ACCESS_FINE_LOCATION,
+      },
+      alias = CameraPreview.CAMERA_WITH_LOCATION_PERMISSION_ALIAS
+    ),
   }
 )
 public class CameraPreview
@@ -45,16 +58,23 @@ public class CameraPreview
 
   static final String CAMERA_WITH_AUDIO_PERMISSION_ALIAS = "cameraWithAudio";
   static final String CAMERA_ONLY_PERMISSION_ALIAS = "cameraOnly";
+  static final String CAMERA_WITH_LOCATION_PERMISSION_ALIAS =
+    "cameraWithLocation";
 
   private String captureCallbackId = "";
   private String snapshotCallbackId = "";
   private String cameraStartCallbackId = "";
-  private int previousOrientationRequest = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
+  private int previousOrientationRequest =
+    ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
   private CameraXView cameraXView;
+  private FusedLocationProviderClient fusedLocationClient;
+  private Location lastLocation;
 
   @PluginMethod
   public void start(PluginCall call) {
-    boolean disableAudio = Boolean.TRUE.equals(call.getBoolean("disableAudio", true));
+    boolean disableAudio = Boolean.TRUE.equals(
+      call.getBoolean("disableAudio", true)
+    );
     String permissionAlias = disableAudio
       ? CAMERA_ONLY_PERMISSION_ALIAS
       : CAMERA_WITH_AUDIO_PERMISSION_ALIAS;
@@ -87,12 +107,74 @@ public class CameraPreview
       return;
     }
 
+    final boolean withExifLocation = call.getBoolean("withExifLocation", false);
+
+    if (withExifLocation) {
+      if (
+        getPermissionState(CAMERA_WITH_LOCATION_PERMISSION_ALIAS) !=
+        PermissionState.GRANTED
+      ) {
+        requestPermissionForAlias(
+          CAMERA_WITH_LOCATION_PERMISSION_ALIAS,
+          call,
+          "captureWithLocationPermission"
+        );
+      } else {
+        getLocationAndCapture(call);
+      }
+    } else {
+      captureWithoutLocation(call);
+    }
+  }
+
+  @PermissionCallback
+  private void captureWithLocationPermission(PluginCall call) {
+    if (
+      getPermissionState(CAMERA_WITH_LOCATION_PERMISSION_ALIAS) ==
+      PermissionState.GRANTED
+    ) {
+      getLocationAndCapture(call);
+    } else {
+      Logger.warn(
+        "Location permission denied. Capturing photo without location data."
+      );
+      captureWithoutLocation(call);
+    }
+  }
+
+  private void getLocationAndCapture(PluginCall call) {
+    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());
+        proceedWithCapture(call, null);
+      });
+  }
+
+  private void captureWithoutLocation(PluginCall call) {
+    proceedWithCapture(call, null);
+  }
+
+  private void proceedWithCapture(PluginCall call, Location location) {
     bridge.saveCall(call);
     captureCallbackId = call.getCallbackId();
 
     Integer quality = Objects.requireNonNull(call.getInt("quality", 85));
-    final boolean saveToGallery = Boolean.TRUE.equals(call.getBoolean("saveToGallery", false));
-    cameraXView.capturePhoto(quality, saveToGallery);
+    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, aspectRatio, location);
   }
 
   @PluginMethod
@@ -111,19 +193,17 @@ public class CameraPreview
   public void stop(final PluginCall call) {
     bridge
       .getActivity()
-      .runOnUiThread(
-        () -> {
-          getBridge()
-            .getActivity()
-            .setRequestedOrientation(previousOrientationRequest);
+      .runOnUiThread(() -> {
+        getBridge()
+          .getActivity()
+          .setRequestedOrientation(previousOrientationRequest);
 
-          if (cameraXView != null && cameraXView.isRunning()) {
-            cameraXView.stopSession();
-            cameraXView = null;
-          }
-          call.resolve();
+        if (cameraXView != null && cameraXView.isRunning()) {
+          cameraXView.stopSession();
+          cameraXView = null;
         }
-      );
+        call.resolve();
+      });
   }
 
   @PluginMethod
@@ -151,7 +231,9 @@ public class CameraPreview
 
   @PluginMethod
   public void getAvailableDevices(PluginCall call) {
-    List<CameraDevice> devices = CameraXView.getAvailableDevicesStatic(getContext());
+    List<CameraDevice> devices = CameraXView.getAvailableDevicesStatic(
+      getContext()
+    );
     JSArray devicesArray = new JSArray();
     for (CameraDevice device : devices) {
       JSObject deviceJson = new JSObject();
@@ -198,14 +280,44 @@ 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());
     }
   }
 
+  @PluginMethod
+  public void setFocus(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    Float x = call.getFloat("x");
+    Float y = call.getFloat("y");
+    if (x == null || y == null) {
+      call.reject("x and y parameters are required");
+      return;
+    }
+    // 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(x, y);
+          call.resolve();
+        } catch (Exception e) {
+          call.reject("Failed to set focus: " + e.getMessage());
+        }
+      });
+  }
+
   @PluginMethod
   public void setDeviceId(PluginCall call) {
     String deviceId = call.getString("deviceId");
@@ -228,7 +340,7 @@ public class CameraPreview
     JSObject rear = new JSObject();
     rear.put("facing", "rear");
     JSArray rearSizesJs = new JSArray();
-    for(Size size : rearSizes) {
+    for (Size size : rearSizes) {
       JSObject sizeJs = new JSObject();
       sizeJs.put("width", size.getWidth());
       sizeJs.put("height", size.getHeight());
@@ -236,12 +348,12 @@ public class CameraPreview
     }
     rear.put("supportedPictureSizes", rearSizesJs);
     supportedPictureSizesResult.put(rear);
-    
+
     List<Size> frontSizes = CameraXView.getSupportedPictureSizes("front");
     JSObject front = new JSObject();
     front.put("facing", "front");
     JSArray frontSizesJs = new JSArray();
-    for(Size size : frontSizes) {
+    for (Size size : frontSizes) {
       JSObject sizeJs = new JSObject();
       sizeJs.put("width", size.getWidth());
       sizeJs.put("height", size.getHeight());
@@ -249,7 +361,7 @@ public class CameraPreview
     }
     front.put("supportedPictureSizes", frontSizesJs);
     supportedPictureSizesResult.put(front);
-    
+
     JSObject ret = new JSObject();
     ret.put("supportedPictureSizes", supportedPictureSizesResult);
     call.resolve(ret);
@@ -308,8 +420,14 @@ public class CameraPreview
 
   @PermissionCallback
   private void handleCameraPermissionResult(PluginCall call) {
-    if (PermissionState.GRANTED.equals(getPermissionState(CAMERA_ONLY_PERMISSION_ALIAS)) ||
-        PermissionState.GRANTED.equals(getPermissionState(CAMERA_WITH_AUDIO_PERMISSION_ALIAS))) {
+    if (
+      PermissionState.GRANTED.equals(
+        getPermissionState(CAMERA_ONLY_PERMISSION_ALIAS)
+      ) ||
+      PermissionState.GRANTED.equals(
+        getPermissionState(CAMERA_WITH_AUDIO_PERMISSION_ALIAS)
+      )
+    ) {
       startCamera(call);
     } else {
       call.reject("Permission failed");
@@ -321,65 +439,412 @@ public class CameraPreview
     String originalDeviceId = call.getString("deviceId");
     String deviceId = originalDeviceId; // Use a mutable variable
 
-    final String position = (positionParam == null || positionParam.isEmpty() || "rear".equals(positionParam) || "back".equals(positionParam)) ? "back" : "front";
-    final int x = call.getInt("x", 0);
-    final int y = call.getInt("y", 0);
+    final String position = (positionParam == null ||
+        positionParam.isEmpty() ||
+        "rear".equals(positionParam) ||
+        "back".equals(positionParam))
+      ? "back"
+      : "front";
+    // 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);
     final boolean toBack = Boolean.TRUE.equals(call.getBoolean("toBack", true));
-    final boolean storeToFile = Boolean.TRUE.equals(call.getBoolean("storeToFile", false));
-    final boolean enableOpacity = Boolean.TRUE.equals(call.getBoolean("enableOpacity", false));
-    final boolean enableZoom = Boolean.TRUE.equals(call.getBoolean("enableZoom", false));
-    final boolean disableExifHeaderStripping = Boolean.TRUE.equals(call.getBoolean("disableExifHeaderStripping", false));
-    final boolean lockOrientation = Boolean.TRUE.equals(call.getBoolean("lockAndroidOrientation", false));
-    final boolean disableAudio = Boolean.TRUE.equals(call.getBoolean("disableAudio", true));
-    
-    float targetZoom = 1.0f;
+    final boolean storeToFile = Boolean.TRUE.equals(
+      call.getBoolean("storeToFile", false)
+    );
+    final boolean enableOpacity = Boolean.TRUE.equals(
+      call.getBoolean("enableOpacity", false)
+    );
+    final boolean enableZoom = Boolean.TRUE.equals(
+      call.getBoolean("enableZoom", false)
+    );
+    final boolean disableExifHeaderStripping = Boolean.TRUE.equals(
+      call.getBoolean("disableExifHeaderStripping", false)
+    );
+    final boolean lockOrientation = Boolean.TRUE.equals(
+      call.getBoolean("lockAndroidOrientation", false)
+    );
+    final boolean disableAudio = Boolean.TRUE.equals(
+      call.getBoolean("disableAudio", true)
+    );
+    final String aspectRatio = call.getString("aspectRatio", "4:3");
+    final String gridMode = call.getString("gridMode", "none");
+    final String positioning = call.getString("positioning", "center");
+    final float initialZoomLevel = call.getFloat("initialZoomLevel", 1.0f);
+
+    // Check for conflict between aspectRatio and size
+    if (
+      call.getData().has("aspectRatio") &&
+      (call.getData().has("width") || call.getData().has("height"))
+    ) {
+      call.reject(
+        "Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start."
+      );
+      return;
+    }
+
+    float targetZoom = initialZoomLevel;
     // Check if the selected device is a physical ultra-wide
     if (originalDeviceId != null) {
-        List<CameraDevice> devices = CameraXView.getAvailableDevicesStatic(getContext());
-        for (CameraDevice device : devices) {
-            if (originalDeviceId.equals(device.getDeviceId()) && !device.isLogical()) {
-                for (LensInfo lens : device.getLenses()) {
-                    if ("ultraWide".equals(lens.getDeviceType())) {
-                        Log.d("CameraPreview", "Ultra-wide lens selected. Targeting 0.5x zoom on logical camera.");
-                        targetZoom = 0.5f;
-                        // Force the use of the logical camera by clearing the specific deviceId
-                        deviceId = null; 
-                        break;
-                    }
-                }
+      List<CameraDevice> devices = CameraXView.getAvailableDevicesStatic(
+        getContext()
+      );
+      for (CameraDevice device : devices) {
+        if (
+          originalDeviceId.equals(device.getDeviceId()) && !device.isLogical()
+        ) {
+          for (LensInfo lens : device.getLenses()) {
+            if ("ultraWide".equals(lens.getDeviceType())) {
+              Log.d(
+                "CameraPreview",
+                "Ultra-wide lens selected. Targeting 0.5x zoom on logical camera."
+              );
+              targetZoom = 0.5f;
+              // Force the use of the logical camera by clearing the specific deviceId
+              deviceId = null;
+              break;
             }
-            if (deviceId == null) break; // Exit outer loop once we've made our decision
+          }
         }
+        if (deviceId == null) break; // Exit outer loop once we've made our decision
+      }
     }
 
-    previousOrientationRequest = getBridge().getActivity().getRequestedOrientation();
+    previousOrientationRequest = getBridge()
+      .getActivity()
+      .getRequestedOrientation();
     cameraXView = new CameraXView(getContext(), getBridge().getWebView());
     cameraXView.setListener(this);
 
     String finalDeviceId = deviceId;
     float finalTargetZoom = targetZoom;
-    getBridge().getActivity().runOnUiThread(() -> {
-        DisplayMetrics metrics = getBridge().getActivity().getResources().getDisplayMetrics();
+    getBridge()
+      .getActivity()
+      .runOnUiThread(() -> {
+        DisplayMetrics metrics = getBridge()
+          .getActivity()
+          .getResources()
+          .getDisplayMetrics();
         if (lockOrientation) {
-          getBridge().getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);
+          getBridge()
+            .getActivity()
+            .setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);
         }
-        int computedX = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, x, metrics);
-        int computedY = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, y, metrics);
-        int computedWidth = width != 0 ? (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, width, metrics) : getBridge().getWebView().getWidth();
-        int computedHeight = height != 0 ? (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, height, metrics) : getBridge().getWebView().getHeight();
-        computedHeight -= (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, paddingBottom, metrics);
 
-        CameraSessionConfiguration config = new CameraSessionConfiguration(finalDeviceId, position, computedX, computedY, computedWidth, computedHeight, paddingBottom, toBack, storeToFile, enableOpacity, enableZoom, disableExifHeaderStripping, disableAudio, 1.0f);
-        config.setTargetZoom(finalTargetZoom);
+        // Debug: Let's check all the positioning information
+        ViewGroup webViewParent = (ViewGroup) getBridge()
+          .getWebView()
+          .getParent();
+
+        // Get webview position in different coordinate systems
+        int[] webViewLocationInWindow = new int[2];
+        int[] webViewLocationOnScreen = new int[2];
+        getBridge().getWebView().getLocationInWindow(webViewLocationInWindow);
+        getBridge().getWebView().getLocationOnScreen(webViewLocationOnScreen);
+
+        int webViewLeft = getBridge().getWebView().getLeft();
+        int webViewTop = getBridge().getWebView().getTop();
+
+        // Check parent position too
+        int[] parentLocationInWindow = new int[2];
+        int[] parentLocationOnScreen = new int[2];
+        webViewParent.getLocationInWindow(parentLocationInWindow);
+        webViewParent.getLocationOnScreen(parentLocationOnScreen);
+
+        // 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);
+
+        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) {
+          // Position vertically based on positioning parameter
+          int screenHeight = metrics.heightPixels;
+          
+          switch (positioning) {
+            case "top":
+              computedY = 0;
+              Log.d(
+                "CameraPreview",
+                "Positioning at top: computedY=0"
+              );
+              break;
+            case "bottom":
+              computedY = screenHeight - computedHeight;
+              Log.d(
+                "CameraPreview",
+                "Positioning at bottom: screenHeight=" +
+                screenHeight +
+                ", computedHeight=" +
+                computedHeight +
+                ", computedY=" +
+                computedY
+              );
+              break;
+            case "center":
+            default:
+              // 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 = (screenHeight - computedHeight) / 2;
+                Log.d(
+                  "CameraPreview",
+                  "Centering vertically with WebView offset: screenHeight=" +
+                  screenHeight +
+                  ", webViewTop=" +
+                  webViewTopInset +
+                  ", computedHeight=" +
+                  computedHeight +
+                  ", computedY=" +
+                  computedY
+                );
+              } else {
+                // Normal mode - use full screen height
+                computedY = (screenHeight - computedHeight) / 2;
+                Log.d(
+                  "CameraPreview",
+                  "Centering vertically (normal): screenHeight=" +
+                  screenHeight +
+                  ", computedHeight=" +
+                  computedHeight +
+                  ", computedY=" +
+                  computedY
+                );
+              }
+              break;
+          }
+        } 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",
+          "WebView getLeft/getTop: (" + webViewLeft + ", " + webViewTop + ")"
+        );
+        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] +
+          ")"
+        );
+        Log.d(
+          "CameraPreview",
+          "Parent class: " + webViewParent.getClass().getSimpleName()
+        );
+        Log.d(
+          "CameraPreview",
+          "Requested position (logical): (" + x + ", " + y + ")"
+        );
+        Log.d("CameraPreview", "Pixel ratio: " + pixelRatio);
+        Log.d(
+          "CameraPreview",
+          "Final computed position (no offset): (" +
+          computedX +
+          ", " +
+          computedY +
+          ")"
+        );
+        Log.d("CameraPreview", "5. IS_CENTERED - " + (x == -1 || y == -1));
+        Log.d("CameraPreview", "========================");
+
+        // Pass along whether we're centering so CameraXView knows not to add insets
+        boolean isCentered = (x == -1 || y == -1);
+
+        CameraSessionConfiguration config = new CameraSessionConfiguration(
+          finalDeviceId,
+          position,
+          computedX,
+          computedY,
+          computedWidth,
+          computedHeight,
+          paddingBottom,
+          toBack,
+          storeToFile,
+          enableOpacity,
+          enableZoom,
+          disableExifHeaderStripping,
+          disableAudio,
+          1.0f,
+          aspectRatio,
+          gridMode
+        );
+        config.setTargetZoom(finalTargetZoom);
+        config.setCentered(isCentered);
+
         bridge.saveCall(call);
         cameraStartCallbackId = call.getCallbackId();
         cameraXView.startSession(config);
-      }
-    );
+      });
   }
 
   @Override
@@ -407,34 +872,245 @@ public class CameraPreview
     bridge.releaseCall(pluginCall);
   }
 
+  @Override
+  public void onCameraStarted(int width, int height, int x, int y) {
+    PluginCall call = bridge.getSavedCall(cameraStartCallbackId);
+    if (call != null) {
+      // Convert pixel values back to logical units
+      DisplayMetrics metrics = getBridge()
+        .getActivity()
+        .getResources()
+        .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", relativeY / pixelRatio);
+      call.resolve(result);
+      bridge.releaseCall(call);
+      cameraStartCallbackId = null; // Prevent re-use
+    }
+  }
+
   @Override
   public void onSampleTaken(String result) {
-    JSObject jsObject = new JSObject();
-    jsObject.put("value", result);
-    bridge.getSavedCall(snapshotCallbackId).resolve(jsObject);
+    // Handle sample taken if needed
+    Log.i("CameraPreview", "Sample taken: " + result);
   }
 
   @Override
   public void onSampleTakenError(String message) {
-    bridge.getSavedCall(snapshotCallbackId).reject(message);
+    // Handle sample taken error if needed
+    Log.e("CameraPreview", "Sample taken error: " + message);
   }
 
   @Override
-  public void onCameraStarted() {
-    PluginCall pluginCall = bridge.getSavedCall(cameraStartCallbackId);
-    if (pluginCall != null) {
-      pluginCall.resolve();
-      bridge.releaseCall(pluginCall);
+  public void onCameraStartError(String message) {
+    PluginCall call = bridge.getSavedCall(cameraStartCallbackId);
+    if (call != null) {
+      call.reject(message);
+      bridge.releaseCall(call);
+      cameraStartCallbackId = null;
     }
   }
 
-  @Override
-  public void onCameraStartError(String message) {
-    PluginCall pluginCall = bridge.getSavedCall(cameraStartCallbackId);
-    if (pluginCall != null) {
-      pluginCall.reject(message);
-      bridge.releaseCall(pluginCall);
+  @PluginMethod
+  public void setAspectRatio(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    String aspectRatio = call.getString("aspectRatio", "4:3");
+    Float x = call.getFloat("x");
+    Float y = call.getFloat("y");
+
+    getActivity()
+      .runOnUiThread(() -> {
+        cameraXView.setAspectRatio(aspectRatio, x, y, () -> {
+          // Return the actual preview bounds after layout and camera operations are complete
+          int[] bounds = cameraXView.getCurrentPreviewBounds();
+          JSObject ret = new JSObject();
+          ret.put("x", bounds[0]);
+          ret.put("y", bounds[1]);
+          ret.put("width", bounds[2]);
+          ret.put("height", bounds[3]);
+          call.resolve(ret);
+        });
+      });
+  }
+
+  @PluginMethod
+  public void getAspectRatio(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
     }
+    String aspectRatio = cameraXView.getAspectRatio();
+    JSObject ret = new JSObject();
+    ret.put("aspectRatio", aspectRatio);
+    call.resolve(ret);
+  }
+
+  @PluginMethod
+  public void setGridMode(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    String gridMode = call.getString("gridMode", "none");
+    getActivity()
+      .runOnUiThread(() -> {
+        cameraXView.setGridMode(gridMode);
+        call.resolve();
+      });
   }
 
+  @PluginMethod
+  public void getGridMode(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+    JSObject ret = new JSObject();
+    ret.put("gridMode", cameraXView.getGridMode());
+    call.resolve(ret);
+  }
+
+  @PluginMethod
+  public void getPreviewSize(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+
+    // Convert pixel values back to logical units
+    DisplayMetrics metrics = getBridge()
+      .getActivity()
+      .getResources()
+      .getDisplayMetrics();
+    float pixelRatio = metrics.density;
+
+    JSObject ret = new JSObject();
+    ret.put("x", cameraXView.getPreviewX() / pixelRatio);
+    ret.put("y", cameraXView.getPreviewY() / pixelRatio);
+    ret.put("width", cameraXView.getPreviewWidth() / pixelRatio);
+    ret.put("height", cameraXView.getPreviewHeight() / pixelRatio);
+    call.resolve(ret);
+  }
+
+  @PluginMethod
+  public void setPreviewSize(PluginCall call) {
+    if (cameraXView == null || !cameraXView.isRunning()) {
+      call.reject("Camera is not running");
+      return;
+    }
+
+    // Get values from call - null values will become 0
+    Integer xParam = call.getInt("x");
+    Integer yParam = call.getInt("y");
+    Integer widthParam = call.getInt("width");
+    Integer heightParam = call.getInt("height");
+
+    // Apply pixel ratio conversion to non-null values
+    DisplayMetrics metrics = getBridge()
+      .getActivity()
+      .getResources()
+      .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;
+    int height = (heightParam != null && heightParam > 0)
+      ? (int) (heightParam * pixelRatio)
+      : 0;
+
+    cameraXView.setPreviewSize(x, y, width, height, () -> {
+      // Return the actual preview bounds after layout operations are complete
+      int[] bounds = cameraXView.getCurrentPreviewBounds();
+      JSObject ret = new JSObject();
+      ret.put("x", bounds[0]);
+      ret.put("y", bounds[1]);
+      ret.put("width", bounds[2]);
+      ret.put("height", bounds[3]);
+      call.resolve(ret);
+    });
+  }
 }