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

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

@@ -18,6 +18,8 @@ import androidx.camera.core.ImageCapture;
 import androidx.camera.core.ImageCaptureException;
 import androidx.camera.core.ImageProxy;
 import androidx.camera.core.Preview;
+import androidx.camera.core.AspectRatio;
+import androidx.camera.core.resolutionselector.AspectRatioStrategy;
 import androidx.camera.core.resolutionselector.ResolutionSelector;
 import androidx.camera.core.resolutionselector.ResolutionStrategy;
 import androidx.camera.lifecycle.ProcessCameraProvider;
@@ -27,6 +29,7 @@ import androidx.lifecycle.Lifecycle;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LifecycleRegistry;
 import com.ahm.capacitor.camera.preview.model.CameraSessionConfiguration;
+import android.widget.FrameLayout;
 import com.ahm.capacitor.camera.preview.model.LensInfo;
 import com.ahm.capacitor.camera.preview.model.ZoomFactors;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -56,8 +59,17 @@ import java.util.Locale;
 import androidx.exifinterface.media.ExifInterface;
 import org.json.JSONObject;
 import java.nio.file.Files;
-
-public class CameraXView implements LifecycleOwner {
+import android.graphics.BitmapFactory;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import java.io.ByteArrayOutputStream;
+import android.location.Location;
+import android.widget.FrameLayout;
+import androidx.lifecycle.LifecycleObserver;
+import androidx.lifecycle.OnLifecycleEvent;
+import android.util.Rational;
+
+public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private static final String TAG = "CameraPreview CameraXView";
 
     public interface CameraXViewListener {
@@ -74,6 +86,8 @@ public class CameraXView implements LifecycleOwner {
     private ImageCapture imageCapture;
     private ImageCapture sampleImageCapture;
     private PreviewView previewView;
+    private GridOverlayView gridOverlayView;
+    private FrameLayout previewContainer;
     private CameraSelector currentCameraSelector;
     private String currentDeviceId;
     private int currentFlashMode = ImageCapture.FLASH_MODE_OFF;
@@ -174,23 +188,47 @@ public class CameraXView implements LifecycleOwner {
         if (sessionConfig.isToBack()) {
             webView.setBackgroundColor(android.graphics.Color.TRANSPARENT);
         }
+
+        // Create a container to hold both the preview and grid overlay
+        previewContainer = new FrameLayout(context);
+
+        // Create and setup the preview view
         previewView = new PreviewView(context);
         previewView.setScaleType(PreviewView.ScaleType.FILL_CENTER);
+        previewContainer.addView(previewView, new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT
+        ));
+
+        // Create and setup the grid overlay
+        gridOverlayView = new GridOverlayView(context);
+        gridOverlayView.setGridMode(sessionConfig.getGridMode());
+        previewContainer.addView(gridOverlayView, new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT
+        ));
+
         ViewGroup parent = (ViewGroup) webView.getParent();
         if (parent != null) {
-            parent.addView(previewView, new ViewGroup.LayoutParams(sessionConfig.getWidth(), sessionConfig.getHeight()));
+            parent.addView(previewContainer, new ViewGroup.LayoutParams(sessionConfig.getWidth(), sessionConfig.getHeight()));
             if(sessionConfig.isToBack()) webView.bringToFront();
         }
     }
 
     private void removePreviewView() {
-        if (previewView != null) {
-            ViewGroup parent = (ViewGroup) previewView.getParent();
+        if (previewContainer != null) {
+            ViewGroup parent = (ViewGroup) previewContainer.getParent();
             if (parent != null) {
-                parent.removeView(previewView);
+                parent.removeView(previewContainer);
             }
+            previewContainer = null;
+        }
+        if (previewView != null) {
             previewView = null;
         }
+        if (gridOverlayView != null) {
+            gridOverlayView = null;
+        }
         webView.setBackgroundColor(android.graphics.Color.WHITE);
     }
 
@@ -201,9 +239,22 @@ public class CameraXView implements LifecycleOwner {
             try {
                 Log.d(TAG, "Building camera selector with deviceId: " + sessionConfig.getDeviceId() + " and position: " + sessionConfig.getPosition());
                 currentCameraSelector = buildCameraSelector();
-                ResolutionSelector resolutionSelector = new ResolutionSelector.Builder()
-                        .setResolutionStrategy(ResolutionStrategy.HIGHEST_AVAILABLE_STRATEGY)
-                        .build();
+
+                ResolutionSelector.Builder resolutionSelectorBuilder = new ResolutionSelector.Builder()
+                        .setResolutionStrategy(ResolutionStrategy.HIGHEST_AVAILABLE_STRATEGY);
+
+                if (sessionConfig.getAspectRatio() != null) {
+                    int aspectRatio;
+                    if ("16:9".equals(sessionConfig.getAspectRatio())) {
+                        aspectRatio = AspectRatio.RATIO_16_9;
+                    } else { // "4:3"
+                        aspectRatio = AspectRatio.RATIO_4_3;
+                    }
+                    resolutionSelectorBuilder.setAspectRatioStrategy(new AspectRatioStrategy(aspectRatio, AspectRatioStrategy.FALLBACK_RULE_AUTO));
+                }
+
+                ResolutionSelector resolutionSelector = resolutionSelectorBuilder.build();
+
                 Preview preview = new Preview.Builder().setResolutionSelector(resolutionSelector).build();
                 imageCapture = new ImageCapture.Builder().setResolutionSelector(resolutionSelector).setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY).setFlashMode(currentFlashMode).build();
                 sampleImageCapture = imageCapture;
@@ -314,7 +365,7 @@ public class CameraXView implements LifecycleOwner {
         }
     }
 
-    public void capturePhoto(int quality, final boolean saveToGallery) {
+    public void capturePhoto(int quality, final boolean saveToGallery, Integer width, Integer height, Location location) {
         Log.d(TAG, "capturePhoto: Starting photo capture with quality: " + quality);
 
         if (imageCapture == null) {
@@ -342,16 +393,34 @@ public class CameraXView implements LifecycleOwner {
                 @Override
                 public void onImageSaved(@NonNull ImageCapture.OutputFileResults output) {
                     try {
-                        byte[] bytes = Files.readAllBytes(tempFile.toPath());
+                        // Read file using FileInputStream for compatibility
+                        byte[] bytes = new byte[(int) tempFile.length()];
+                        java.io.FileInputStream fis = new java.io.FileInputStream(tempFile);
+                        fis.read(bytes);
+                        fis.close();
+                        
                         ExifInterface exifInterface = new ExifInterface(tempFile.getAbsolutePath());
+
+                        if (location != null) {
+                            exifInterface.setGpsInfo(location);
+                        }
+
                         JSONObject exifData = getExifData(exifInterface);
 
+                        if (width != null && height != null) {
+                            Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+                            Bitmap resizedBitmap = resizeBitmap(bitmap, width, height);
+                            ByteArrayOutputStream stream = new ByteArrayOutputStream();
+                            resizedBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream);
+                            bytes = stream.toByteArray();
+                        }
+
                         if (saveToGallery) {
                             saveImageToGallery(bytes);
                         }
 
                         String base64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
-                        
+
                         tempFile.delete();
 
                         if (listener != null) {
@@ -368,6 +437,10 @@ public class CameraXView implements LifecycleOwner {
         );
     }
 
+    private Bitmap resizeBitmap(Bitmap bitmap, int width, int height) {
+        return Bitmap.createScaledBitmap(bitmap, width, height, true);
+    }
+
     private JSONObject getExifData(ExifInterface exifInterface) {
         JSONObject exifData = new JSONObject();
         try {
@@ -593,7 +666,7 @@ public class CameraXView implements LifecycleOwner {
             for (CameraInfo cameraInfo : cameraProvider.getAvailableCameraInfos()) {
                 String logicalCameraId = Camera2CameraInfo.from(cameraInfo).getCameraId();
                 String position = isBackCamera(cameraInfo) ? "rear" : "front";
-                
+
                 // Add logical camera
                 float minZoom = Objects.requireNonNull(cameraInfo.getZoomState().getValue()).getMinZoomRatio();
                 float maxZoom = cameraInfo.getZoomState().getValue().getMaxZoomRatio();
@@ -629,7 +702,7 @@ public class CameraXView implements LifecycleOwner {
                                 if (focalLengths[0] < 3.0f) deviceType = "ultraWide";
                                 else if (focalLengths[0] > 5.0f) deviceType = "telephoto";
                             }
-                            
+
                             float physicalMinZoom = 1.0f;
                             float physicalMaxZoom = 1.0f;
                             if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
@@ -639,11 +712,11 @@ public class CameraXView implements LifecycleOwner {
                                     physicalMaxZoom = zoomRange.getUpper();
                                 }
                             }
-                            
+
                             String label = "Physical " + deviceType + " (" + position + ")";
                             List<LensInfo> physicalLenses = new ArrayList<>();
                             physicalLenses.add(new LensInfo(focalLengths != null ? focalLengths[0] : 4.25f, deviceType, 1.0f, physicalMaxZoom));
-                            
+
                             devices.add(new com.ahm.capacitor.camera.preview.model.CameraDevice(
                                 physicalId, label, position, physicalLenses, physicalMinZoom, physicalMaxZoom, false
                             ));
@@ -947,7 +1020,9 @@ public class CameraXView implements LifecycleOwner {
             sessionConfig.isEnableZoom(), // enableZoom
             sessionConfig.isDisableExifHeaderStripping(), // disableExifHeaderStripping
             sessionConfig.isDisableAudio(), // disableAudio
-            sessionConfig.getZoomFactor() // zoomFactor
+            sessionConfig.getZoomFactor(), // zoomFactor
+            sessionConfig.getAspectRatio(), // aspectRatio
+            sessionConfig.getGridMode() // gridMode
         );
 
         // Clear current device ID to force position-based selection
@@ -965,4 +1040,64 @@ public class CameraXView implements LifecycleOwner {
             previewView.setAlpha(opacity);
         }
     }
+
+    private void updateLayoutParams() {
+        if (sessionConfig == null) return;
+
+        FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(
+                sessionConfig.getWidth(),
+                sessionConfig.getHeight()
+        );
+        layoutParams.leftMargin = sessionConfig.getX();
+        layoutParams.topMargin = sessionConfig.getY();
+
+        if (sessionConfig.getAspectRatio() != null && !sessionConfig.getAspectRatio().equals("fill")) {
+            String[] ratios = sessionConfig.getAspectRatio().split(":");
+            float ratio = Float.parseFloat(ratios[0]) / Float.parseFloat(ratios[1]);
+            if (sessionConfig.getWidth() > 0) {
+                layoutParams.height = (int) (sessionConfig.getWidth() / ratio);
+            } else if (sessionConfig.getHeight() > 0) {
+                layoutParams.width = (int) (sessionConfig.getHeight() * ratio);
+            }
+        } else {
+            previewView.setScaleType(PreviewView.ScaleType.FILL_CENTER);
+        }
+
+        previewView.setLayoutParams(layoutParams);
+
+        if (listener != null) {
+            listener.onCameraStarted();
+        }
+    }
+
+    public String getAspectRatio() {
+        if (sessionConfig != null) {
+            return sessionConfig.getAspectRatio();
+        }
+        return "fill";
+    }
+
+    public void setAspectRatio(String aspectRatio) {
+        if (sessionConfig != null) {
+            sessionConfig = new CameraSessionConfiguration(
+                    sessionConfig.getDeviceId(),
+                    sessionConfig.getPosition(),
+                    sessionConfig.getX(),
+                    sessionConfig.getY(),
+                    sessionConfig.getWidth(),
+                    sessionConfig.getHeight(),
+                    sessionConfig.getPaddingBottom(),
+                    sessionConfig.getToBack(),
+                    sessionConfig.getStoreToFile(),
+                    sessionConfig.getEnableOpacity(),
+                    sessionConfig.getEnableZoom(),
+                    sessionConfig.getDisableExifHeaderStripping(),
+                    sessionConfig.getDisableAudio(),
+                    sessionConfig.getZoomFactor(),
+                    aspectRatio,
+                    sessionConfig.getGridMode()
+            );
+            updateLayoutParams();
+        }
+    }
 }

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

@@ -0,0 +1,80 @@
+package com.ahm.capacitor.camera.preview;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.util.AttributeSet;
+import android.view.View;
+
+public class GridOverlayView extends View {
+    private Paint gridPaint;
+    private String gridMode = "none";
+
+    public GridOverlayView(Context context) {
+        super(context);
+        init();
+    }
+
+    public GridOverlayView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public GridOverlayView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    private void init() {
+        gridPaint = new Paint();
+        gridPaint.setColor(0x80FFFFFF); // Semi-transparent white
+        gridPaint.setStrokeWidth(2f);
+        gridPaint.setStyle(Paint.Style.STROKE);
+        gridPaint.setAntiAlias(true);
+    }
+
+    public void setGridMode(String mode) {
+        this.gridMode = mode != null ? mode : "none";
+        setVisibility("none".equals(this.gridMode) ? View.GONE : View.VISIBLE);
+        invalidate();
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+
+        if ("none".equals(gridMode)) {
+            return;
+        }
+
+        int width = getWidth();
+        int height = getHeight();
+
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+
+        if ("3x3".equals(gridMode)) {
+            drawGrid(canvas, width, height, 3);
+        } else if ("4x4".equals(gridMode)) {
+            drawGrid(canvas, width, height, 4);
+        }
+    }
+
+    private void drawGrid(Canvas canvas, 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);
+        }
+
+        // Draw horizontal lines
+        for (int i = 1; i < divisions; i++) {
+            float y = i * stepY;
+            canvas.drawLine(0, y, width, y, gridPaint);
+        }
+    }
+}

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

@@ -18,12 +18,14 @@ public class CameraSessionConfiguration {
     private final boolean disableExifHeaderStripping;
     private final boolean disableAudio;
     private final float zoomFactor;
+    private final String aspectRatio;
+    private final String gridMode;
     private float targetZoom = 1.0f;
 
-    public CameraSessionConfiguration(String deviceId, String position, int x, int y, int width, int height, 
-                                    int paddingBottom, boolean toBack, boolean storeToFile, boolean enableOpacity, 
-                                    boolean enableZoom, boolean disableExifHeaderStripping, boolean disableAudio, 
-                                    float zoomFactor) {
+    public CameraSessionConfiguration(String deviceId, String position, int x, int y, int width, int height,
+                                    int paddingBottom, boolean toBack, boolean storeToFile, boolean enableOpacity,
+                                    boolean enableZoom, boolean disableExifHeaderStripping, boolean disableAudio,
+                                    float zoomFactor, String aspectRatio, String gridMode) {
         this.deviceId = deviceId;
         this.position = position;
         this.x = x;
@@ -38,6 +40,8 @@ public class CameraSessionConfiguration {
         this.disableExifHeaderStripping = disableExifHeaderStripping;
         this.disableAudio = disableAudio;
         this.zoomFactor = zoomFactor;
+        this.aspectRatio = aspectRatio;
+        this.gridMode = gridMode != null ? gridMode : "none";
     }
 
     public void setTargetZoom(float zoom) {
@@ -62,4 +66,14 @@ public class CameraSessionConfiguration {
     public boolean isDisableExifHeaderStripping() { return disableExifHeaderStripping; }
     public boolean isDisableAudio() { return disableAudio; }
     public float getZoomFactor() { return zoomFactor; }
-} 
+    public String getAspectRatio() { return aspectRatio; }
+    public String getGridMode() { return gridMode; }
+
+    // Additional getters with "get" prefix for compatibility
+    public boolean getToBack() { return toBack; }
+    public boolean getStoreToFile() { return storeToFile; }
+    public boolean getEnableOpacity() { return enableOpacity; }
+    public boolean getEnableZoom() { return enableZoom; }
+    public boolean getDisableExifHeaderStripping() { return disableExifHeaderStripping; }
+    public boolean getDisableAudio() { return disableAudio; }
+}

package/dist/docs.json

@@ -7,7 +7,7 @@
     "methods": [
       {
         "name": "start",
-        "signature": "(options: CameraPreviewOptions) => Promise<void>",
+        "signature": "(options: CameraPreviewOptions) => Promise<{ width: number; height: number; x: number; y: number; }>",
         "parameters": [
           {
             "name": "options",
@@ -15,7 +15,7 @@
             "type": "CameraPreviewOptions"
           }
         ],
-        "returns": "Promise<void>",
+        "returns": "Promise<{ width: number; height: number; x: number; y: number; }>",
         "tags": [
           {
             "name": "param",
@@ -23,7 +23,7 @@
           },
           {
             "name": "returns",
-            "text": "A promise that resolves when the camera preview is started."
+            "text": "A promise that resolves with the preview dimensions."
           },
           {
             "name": "since",
@@ -139,6 +139,54 @@
         ],
         "slug": "getsupportedflashmodes"
       },
+      {
+        "name": "setAspectRatio",
+        "signature": "(options: { aspectRatio: '4:3' | '16:9' | 'fill'; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- The desired aspect ratio.",
+            "type": "{ aspectRatio: '4:3' | '16:9' | 'fill'; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options - The desired aspect ratio."
+          },
+          {
+            "name": "returns",
+            "text": "A promise that resolves when the aspect ratio is set."
+          },
+          {
+            "name": "since",
+            "text": "7.4.0"
+          }
+        ],
+        "docs": "Set the aspect ratio of the camera preview.",
+        "complexTypes": [],
+        "slug": "setaspectratio"
+      },
+      {
+        "name": "getAspectRatio",
+        "signature": "() => Promise<{ aspectRatio: '4:3' | '16:9' | 'fill'; }>",
+        "parameters": [],
+        "returns": "Promise<{ aspectRatio: '4:3' | '16:9' | 'fill'; }>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "A promise that resolves with the current aspect ratio."
+          },
+          {
+            "name": "since",
+            "text": "7.4.0"
+          }
+        ],
+        "docs": "Gets the current aspect ratio of the camera preview.",
+        "complexTypes": [],
+        "slug": "getaspectratio"
+      },
       {
         "name": "getHorizontalFov",
         "signature": "() => Promise<{ result: number; }>",
@@ -567,6 +615,36 @@
           "complexTypes": [],
           "type": "number | undefined"
         },
+        {
+          "name": "aspectRatio",
+          "tags": [
+            {
+              "text": "2.0.0",
+              "name": "since"
+            }
+          ],
+          "docs": "The aspect ratio of the camera preview, '4:3' or '16:9'.\nIf not set, the camera will use the default aspect ratio.",
+          "complexTypes": [],
+          "type": "'4:3' | '16:9' | 'fill' | undefined"
+        },
+        {
+          "name": "gridMode",
+          "tags": [
+            {
+              "text": "\"none\"",
+              "name": "default"
+            },
+            {
+              "text": "2.1.0",
+              "name": "since"
+            }
+          ],
+          "docs": "The grid overlay to display on the camera preview.",
+          "complexTypes": [
+            "GridMode"
+          ],
+          "type": "GridMode"
+        },
         {
           "name": "includeSafeAreaInsets",
           "tags": [
@@ -689,7 +767,7 @@
           "name": "disableAudio",
           "tags": [
             {
-              "text": "false",
+              "text": "true",
               "name": "default"
             }
           ],
@@ -845,6 +923,22 @@
           "docs": "If true, the captured image will be saved to the user's gallery.",
           "complexTypes": [],
           "type": "boolean | undefined"
+        },
+        {
+          "name": "withExifLocation",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "7.6.0",
+              "name": "since"
+            }
+          ],
+          "docs": "If true, the plugin will attempt to add GPS location data to the image's EXIF metadata.\nThis may prompt the user for location permissions.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },
@@ -1144,6 +1238,25 @@
     }
   ],
   "typeAliases": [
+    {
+      "name": "GridMode",
+      "slug": "gridmode",
+      "docs": "",
+      "types": [
+        {
+          "text": "\"none\"",
+          "complexTypes": []
+        },
+        {
+          "text": "\"3x3\"",
+          "complexTypes": []
+        },
+        {
+          "text": "\"4x4\"",
+          "complexTypes": []
+        }
+      ]
+    },
     {
       "name": "CameraPosition",
       "slug": "cameraposition",

package/dist/esm/definitions.d.ts

@@ -1,5 +1,6 @@
 export type CameraPosition = "rear" | "front";
 export type FlashMode = CameraPreviewFlashMode;
+export type GridMode = "none" | "3x3" | "4x4";
 export declare enum DeviceType {
     ULTRA_WIDE = "ultraWide",
     WIDE_ANGLE = "wideAngle",
@@ -92,6 +93,19 @@ export interface CameraPreviewOptions {
      * @platform android, ios
      */
     y?: number;
+    /**
+     * The aspect ratio of the camera preview, '4:3' or '16:9'.
+     * If not set, the camera will use the default aspect ratio.
+     *
+     * @since 2.0.0
+     */
+    aspectRatio?: '4:3' | '16:9' | 'fill';
+    /**
+     * The grid overlay to display on the camera preview.
+     * @default "none"
+     * @since 2.1.0
+     */
+    gridMode?: GridMode;
     /**
      * Adjusts the y-position to account for safe areas (e.g., notches).
      * @platform ios
@@ -140,7 +154,7 @@ export interface CameraPreviewOptions {
     enableHighResolution?: boolean;
     /**
      * If true, disables the audio stream, preventing audio permission requests.
-     * @default false
+     * @default true
      */
     disableAudio?: boolean;
     /**
@@ -198,6 +212,13 @@ export interface CameraPreviewPictureOptions {
      * @since 7.5.0
      */
     saveToGallery?: boolean;
+    /**
+     * 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.
+     * @default false
+     * @since 7.6.0
+     */
+    withExifLocation?: boolean;
 }
 /** Represents EXIF data extracted from an image. */
 export interface ExifData {
@@ -251,10 +272,19 @@ export interface CameraPreviewPlugin {
      * Starts the camera preview.
      *
      * @param {CameraPreviewOptions} options - The configuration for the camera preview.
-     * @returns {Promise<void>} A promise that resolves when the camera preview is started.
+     * @returns {Promise<{ width: number; height: number; x: number; y: number }>} A promise that resolves with the preview dimensions.
      * @since 0.0.1
      */
-    start(options: CameraPreviewOptions): Promise<void>;
+    start(options: CameraPreviewOptions): Promise<{
+        /** The width of the preview in pixels. */
+        width: number;
+        /** The height of the preview in pixels. */
+        height: number;
+        /** The horizontal origin of the preview, in pixels. */
+        x: number;
+        /** The vertical origin of the preview, in pixels. */
+        y: number;
+    }>;
     /**
      * Stops the camera preview.
      *
@@ -293,6 +323,25 @@ export interface CameraPreviewPlugin {
     getSupportedFlashModes(): Promise<{
         result: CameraPreviewFlashMode[];
     }>;
+    /**
+     * Set the aspect ratio of the camera preview.
+     *
+     * @param {{ aspectRatio: '4:3' | '16:9' | 'fill' }} options - The desired aspect ratio.
+     * @returns {Promise<void>} A promise that resolves when the aspect ratio is set.
+     * @since 7.4.0
+     */
+    setAspectRatio(options: {
+        aspectRatio: '4:3' | '16:9' | 'fill';
+    }): Promise<void>;
+    /**
+     * Gets the current aspect ratio of the camera preview.
+     *
+     * @returns {Promise<{ aspectRatio: '4:3' | '16:9' | 'fill' }>} A promise that resolves with the current aspect ratio.
+     * @since 7.4.0
+     */
+    getAspectRatio(): Promise<{
+        aspectRatio: '4:3' | '16:9' | 'fill';
+    }>;
     /**
      * Gets the horizontal field of view (FoV) for the active camera.
      * Note: This can be an estimate on some devices.