@capgo/camera-preview 7.4.0-beta.1 → 7.4.0-beta.10

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

@@ -4,8 +4,8 @@ import android.content.Context;
 import android.hardware.camera2.CameraAccessException;
 import android.hardware.camera2.CameraManager;
 import android.os.Build;
-import android.os.HandlerThread;
 import android.util.Base64;
+import android.util.DisplayMetrics;
 import android.util.Log;
 import android.util.Size;
 import android.view.ViewGroup;
@@ -19,6 +19,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;
@@ -28,37 +30,56 @@ 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;
 import java.nio.ByteBuffer;
-import java.nio.file.Files;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.Objects;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import androidx.camera.camera2.interop.Camera2CameraInfo;
 import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
 import android.hardware.camera2.CameraCharacteristics;
-import androidx.camera.extensions.ExtensionMode;
 import java.util.Set;
 import androidx.camera.core.ZoomState;
 import androidx.camera.core.ResolutionInfo;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Environment;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+import androidx.exifinterface.media.ExifInterface;
+import org.json.JSONObject;
+import java.nio.file.Files;
+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;
+import android.view.ViewGroup;
 
-public class CameraXView implements LifecycleOwner {
+public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private static final String TAG = "CameraPreview CameraXView";
 
     public interface CameraXViewListener {
-        void onPictureTaken(String result);
+        void onPictureTaken(String base64, JSONObject exif);
         void onPictureTakenError(String message);
         void onSampleTaken(String result);
         void onSampleTakenError(String message);
-        void onCameraStarted();
+        void onCameraStarted(int width, int height, int x, int y);
         void onCameraStartError(String message);
     }
 
@@ -67,6 +88,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;
@@ -102,6 +125,26 @@ public class CameraXView implements LifecycleOwner {
         return isRunning;
     }
 
+    private void saveImageToGallery(byte[] data) {
+        try {
+            File photo = new File(
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
+                "IMG_" + new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(new java.util.Date()) + ".jpg"
+            );
+            FileOutputStream fos = new FileOutputStream(photo);
+            fos.write(data);
+            fos.close();
+
+            // Notify the gallery of the new image
+            Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
+            Uri contentUri = Uri.fromFile(photo);
+            mediaScanIntent.setData(contentUri);
+            context.sendBroadcast(mediaScanIntent);
+        } catch (IOException e) {
+            Log.e(TAG, "Error saving image to gallery", e);
+        }
+    }
+
     public void startSession(CameraSessionConfiguration config) {
         this.sessionConfig = config;
         cameraExecutor = Executors.newSingleThreadExecutor();
@@ -147,35 +190,140 @@ 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);
+        previewView.setScaleType(PreviewView.ScaleType.FIT_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);
+        previewContainer.addView(gridOverlayView, new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT
+        ));
+        // Set grid mode after adding to container to ensure proper layout
+        gridOverlayView.post(() -> {
+            String currentGridMode = sessionConfig.getGridMode();
+            Log.d(TAG, "setupPreviewView: Setting grid mode to: " + currentGridMode);
+            gridOverlayView.setGridMode(currentGridMode);
+        });
+
         ViewGroup parent = (ViewGroup) webView.getParent();
         if (parent != null) {
-            parent.addView(previewView, new ViewGroup.LayoutParams(sessionConfig.getWidth(), sessionConfig.getHeight()));
+            FrameLayout.LayoutParams layoutParams = calculatePreviewLayoutParams();
+            parent.addView(previewContainer, layoutParams);
             if(sessionConfig.isToBack()) webView.bringToFront();
         }
     }
 
+    private FrameLayout.LayoutParams calculatePreviewLayoutParams() {
+        // sessionConfig already contains pixel-converted coordinates with webview offsets applied
+        int x = sessionConfig.getX();
+        int y = sessionConfig.getY();
+        int width = sessionConfig.getWidth();
+        int height = sessionConfig.getHeight();
+        String aspectRatio = sessionConfig.getAspectRatio();
+        
+        Log.d(TAG, "calculatePreviewLayoutParams: Using sessionConfig values - x:" + x + " y:" + y + " width:" + width + " height:" + height + " aspectRatio:" + aspectRatio);
+        
+        // Apply aspect ratio if specified and no explicit size was given
+        if (aspectRatio != null && !aspectRatio.isEmpty()) {
+            String[] ratios = aspectRatio.split(":");
+            if (ratios.length == 2) {
+                try {
+                    // For camera, use portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
+                    float ratio = Float.parseFloat(ratios[1]) / Float.parseFloat(ratios[0]);
+                    
+                    // Calculate optimal size while maintaining aspect ratio
+                    int optimalWidth = width;
+                    int optimalHeight = (int) (width / ratio);
+                    
+                    if (optimalHeight > height) {
+                        // Height constraint is tighter, fit by height
+                        optimalHeight = height;
+                        optimalWidth = (int) (height * ratio);
+                    }
+                    
+                    width = optimalWidth;
+                    height = optimalHeight;
+                    Log.d(TAG, "calculatePreviewLayoutParams: Applied aspect ratio " + aspectRatio + " - new size: " + width + "x" + height);
+                } catch (NumberFormatException e) {
+                    Log.e(TAG, "Invalid aspect ratio format: " + aspectRatio, e);
+                }
+            }
+        }
+        
+        FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(width, height);
+        
+        // Only add insets for positioning coordinates, not for full-screen sizes
+        int webViewTopInset = getWebViewTopInset();
+        int webViewLeftInset = getWebViewLeftInset();
+        
+        // Don't add insets if this looks like a calculated full-screen coordinate (x=0, y=0)
+        if (x == 0 && y == 0) {
+            layoutParams.leftMargin = x;
+            layoutParams.topMargin = y;
+            Log.d(TAG, "calculatePreviewLayoutParams: Full-screen mode - keeping position (0,0) without insets");
+        } else {
+            layoutParams.leftMargin = x + webViewLeftInset;
+            layoutParams.topMargin = y + webViewTopInset;
+            Log.d(TAG, "calculatePreviewLayoutParams: Positioned mode - applying insets");
+        }
+        
+        Log.d(TAG, "calculatePreviewLayoutParams: Applied insets - x:" + x + "+" + webViewLeftInset + "=" + layoutParams.leftMargin + 
+              ", y:" + y + "+" + webViewTopInset + "=" + layoutParams.topMargin);
+        
+        Log.d(TAG, "calculatePreviewLayoutParams: Final layout - x:" + x + " y:" + y + " width:" + width + " height:" + height);
+        return layoutParams;
+    }
+    
     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);
     }
 
+    @OptIn(markerClass = ExperimentalCamera2Interop.class)
     private void bindCameraUseCases() {
         if (cameraProvider == null) return;
         mainExecutor.execute(() -> {
             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;
@@ -188,7 +336,6 @@ public class CameraXView implements LifecycleOwner {
                 Log.d(TAG, "Use cases bound. Inspecting active camera and use cases.");
                 CameraInfo cameraInfo = camera.getCameraInfo();
                 Log.d(TAG, "Bound Camera ID: " + Camera2CameraInfo.from(cameraInfo).getCameraId());
-                Log.d(TAG, "Implementation Type: " + cameraInfo.getImplementationType());
 
                 // Log zoom state
                 ZoomState zoomState = cameraInfo.getZoomState().getValue();
@@ -227,7 +374,17 @@ public class CameraXView implements LifecycleOwner {
 
                 isRunning = true;
                 Log.d(TAG, "bindCameraUseCases: Camera bound successfully");
-                if (listener != null) listener.onCameraStarted();
+                if (listener != null) {
+                    // Post the callback to ensure layout is complete
+                    previewContainer.post(() -> {
+                        // Return actual preview container dimensions instead of requested dimensions
+                        int actualWidth = previewContainer != null ? previewContainer.getWidth() : sessionConfig.getWidth();
+                        int actualHeight = previewContainer != null ? previewContainer.getHeight() : sessionConfig.getHeight();
+                        int actualX = previewContainer != null ? previewContainer.getLeft() : sessionConfig.getX();
+                        int actualY = previewContainer != null ? previewContainer.getTop() : sessionConfig.getY();
+                        listener.onCameraStarted(actualWidth, actualHeight, actualX, actualY);
+                    });
+                }
             } catch (Exception e) {
                 if (listener != null) listener.onCameraStartError("Error binding camera: " + e.getMessage());
             }
@@ -256,22 +413,6 @@ public class CameraXView implements LifecycleOwner {
         return builder.build();
     }
 
-    private static boolean isIsLogical(CameraManager cameraManager, String cameraId) throws CameraAccessException {
-        CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
-        int[] capabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
-
-        boolean isLogical = false;
-        if (capabilities != null) {
-           for (int capability : capabilities) {
-               if (capability == CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
-                   isLogical = true;
-                   break;
-               }
-           }
-        }
-        return isLogical;
-    }
-
     private static String getCameraId(androidx.camera.core.CameraInfo cameraInfo) {
         try {
             // Generate a stable ID based on camera characteristics
@@ -303,7 +444,7 @@ public class CameraXView implements LifecycleOwner {
         }
     }
 
-    public void capturePhoto(int quality) {
+    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) {
@@ -313,9 +454,8 @@ public class CameraXView implements LifecycleOwner {
             return;
         }
 
-        ImageCapture.OutputFileOptions outputFileOptions = new ImageCapture.OutputFileOptions.Builder(
-            new java.io.File(context.getCacheDir(), "temp_image.jpg")
-        ).build();
+        File tempFile = new File(context.getCacheDir(), "temp_image.jpg");
+        ImageCapture.OutputFileOptions outputFileOptions = new ImageCapture.OutputFileOptions.Builder(tempFile).build();
 
         imageCapture.takePicture(
             outputFileOptions,
@@ -331,31 +471,52 @@ public class CameraXView implements LifecycleOwner {
 
                 @Override
                 public void onImageSaved(@NonNull ImageCapture.OutputFileResults output) {
-                    // Convert to base64
                     try {
-                        java.io.File tempFile = new java.io.File(context.getCacheDir(), "temp_image.jpg");
-                        byte[] bytes;
+                        // 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);
+                        }
 
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                            bytes = Files.readAllBytes(tempFile.toPath());
+                        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();
+                            
+                            // Write EXIF data back to resized image
+                            bytes = writeExifToImageBytes(bytes, exifInterface);
                         } else {
-                            // Fallback for older Android versions
-                            java.io.FileInputStream fis = new java.io.FileInputStream(tempFile);
+                            // For non-resized images, ensure EXIF is saved
+                            exifInterface.saveAttributes();
                             bytes = new byte[(int) tempFile.length()];
-                            fis.read(bytes);
-                            fis.close();
+                            java.io.FileInputStream fis2 = new java.io.FileInputStream(tempFile);
+                            fis2.read(bytes);
+                            fis2.close();
+                        }
+
+                        if (saveToGallery) {
+                            saveImageToGallery(bytes);
                         }
 
                         String base64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
 
-                        // Clean up temp file
                         tempFile.delete();
 
                         if (listener != null) {
-                            listener.onPictureTaken(base64);
+                            listener.onPictureTaken(base64, exifData);
                         }
                     } catch (Exception e) {
-                        Log.e(TAG, "capturePhoto: Error converting to base64", e);
+                        Log.e(TAG, "capturePhoto: Error processing image", e);
                         if (listener != null) {
                             listener.onPictureTakenError("Error processing image: " + e.getMessage());
                         }
@@ -365,6 +526,210 @@ 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 {
+            // Add all available exif tags to a JSON object
+            for (String[] tag : EXIF_TAGS) {
+                String value = exifInterface.getAttribute(tag[0]);
+                if (value != null) {
+                    exifData.put(tag[1], value);
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "getExifData: Error reading exif data", e);
+        }
+        return exifData;
+    }
+
+    private static final String[][] EXIF_TAGS = new String[][]{
+        {ExifInterface.TAG_APERTURE_VALUE, "ApertureValue"},
+        {ExifInterface.TAG_ARTIST, "Artist"},
+        {ExifInterface.TAG_BITS_PER_SAMPLE, "BitsPerSample"},
+        {ExifInterface.TAG_BRIGHTNESS_VALUE, "BrightnessValue"},
+        {ExifInterface.TAG_CFA_PATTERN, "CFAPattern"},
+        {ExifInterface.TAG_COLOR_SPACE, "ColorSpace"},
+        {ExifInterface.TAG_COMPONENTS_CONFIGURATION, "ComponentsConfiguration"},
+        {ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL, "CompressedBitsPerPixel"},
+        {ExifInterface.TAG_COMPRESSION, "Compression"},
+        {ExifInterface.TAG_CONTRAST, "Contrast"},
+        {ExifInterface.TAG_COPYRIGHT, "Copyright"},
+        {ExifInterface.TAG_CUSTOM_RENDERED, "CustomRendered"},
+        {ExifInterface.TAG_DATETIME, "DateTime"},
+        {ExifInterface.TAG_DATETIME_DIGITIZED, "DateTimeDigitized"},
+        {ExifInterface.TAG_DATETIME_ORIGINAL, "DateTimeOriginal"},
+        {ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION, "DeviceSettingDescription"},
+        {ExifInterface.TAG_DIGITAL_ZOOM_RATIO, "DigitalZoomRatio"},
+        {ExifInterface.TAG_DNG_VERSION, "DNGVersion"},
+        {ExifInterface.TAG_EXIF_VERSION, "ExifVersion"},
+        {ExifInterface.TAG_EXPOSURE_BIAS_VALUE, "ExposureBiasValue"},
+        {ExifInterface.TAG_EXPOSURE_INDEX, "ExposureIndex"},
+        {ExifInterface.TAG_EXPOSURE_MODE, "ExposureMode"},
+        {ExifInterface.TAG_EXPOSURE_PROGRAM, "ExposureProgram"},
+        {ExifInterface.TAG_EXPOSURE_TIME, "ExposureTime"},
+        {ExifInterface.TAG_FILE_SOURCE, "FileSource"},
+        {ExifInterface.TAG_FLASH, "Flash"},
+        {ExifInterface.TAG_FLASHPIX_VERSION, "FlashpixVersion"},
+        {ExifInterface.TAG_FLASH_ENERGY, "FlashEnergy"},
+        {ExifInterface.TAG_FOCAL_LENGTH, "FocalLength"},
+        {ExifInterface.TAG_FOCAL_LENGTH_IN_35MM_FILM, "FocalLengthIn35mmFilm"},
+        {ExifInterface.TAG_FOCAL_PLANE_RESOLUTION_UNIT, "FocalPlaneResolutionUnit"},
+        {ExifInterface.TAG_FOCAL_PLANE_X_RESOLUTION, "FocalPlaneXResolution"},
+        {ExifInterface.TAG_FOCAL_PLANE_Y_RESOLUTION, "FocalPlaneYResolution"},
+        {ExifInterface.TAG_F_NUMBER, "FNumber"},
+        {ExifInterface.TAG_GAIN_CONTROL, "GainControl"},
+        {ExifInterface.TAG_GPS_ALTITUDE, "GPSAltitude"},
+        {ExifInterface.TAG_GPS_ALTITUDE_REF, "GPSAltitudeRef"},
+        {ExifInterface.TAG_GPS_AREA_INFORMATION, "GPSAreaInformation"},
+        {ExifInterface.TAG_GPS_DATESTAMP, "GPSDateStamp"},
+        {ExifInterface.TAG_GPS_DEST_BEARING, "GPSDestBearing"},
+        {ExifInterface.TAG_GPS_DEST_BEARING_REF, "GPSDestBearingRef"},
+        {ExifInterface.TAG_GPS_DEST_DISTANCE, "GPSDestDistance"},
+        {ExifInterface.TAG_GPS_DEST_DISTANCE_REF, "GPSDestDistanceRef"},
+        {ExifInterface.TAG_GPS_DEST_LATITUDE, "GPSDestLatitude"},
+        {ExifInterface.TAG_GPS_DEST_LATITUDE_REF, "GPSDestLatitudeRef"},
+        {ExifInterface.TAG_GPS_DEST_LONGITUDE, "GPSDestLongitude"},
+        {ExifInterface.TAG_GPS_DEST_LONGITUDE_REF, "GPSDestLongitudeRef"},
+        {ExifInterface.TAG_GPS_DIFFERENTIAL, "GPSDifferential"},
+        {ExifInterface.TAG_GPS_DOP, "GPSDOP"},
+        {ExifInterface.TAG_GPS_IMG_DIRECTION, "GPSImgDirection"},
+        {ExifInterface.TAG_GPS_IMG_DIRECTION_REF, "GPSImgDirectionRef"},
+        {ExifInterface.TAG_GPS_LATITUDE, "GPSLatitude"},
+        {ExifInterface.TAG_GPS_LATITUDE_REF, "GPSLatitudeRef"},
+        {ExifInterface.TAG_GPS_LONGITUDE, "GPSLongitude"},
+        {ExifInterface.TAG_GPS_LONGITUDE_REF, "GPSLongitudeRef"},
+        {ExifInterface.TAG_GPS_MAP_DATUM, "GPSMapDatum"},
+        {ExifInterface.TAG_GPS_MEASURE_MODE, "GPSMeasureMode"},
+        {ExifInterface.TAG_GPS_PROCESSING_METHOD, "GPSProcessingMethod"},
+        {ExifInterface.TAG_GPS_SATELLITES, "GPSSatellites"},
+        {ExifInterface.TAG_GPS_SPEED, "GPSSpeed"},
+        {ExifInterface.TAG_GPS_SPEED_REF, "GPSSpeedRef"},
+        {ExifInterface.TAG_GPS_STATUS, "GPSStatus"},
+        {ExifInterface.TAG_GPS_TIMESTAMP, "GPSTimeStamp"},
+        {ExifInterface.TAG_GPS_TRACK, "GPSTrack"},
+        {ExifInterface.TAG_GPS_TRACK_REF, "GPSTrackRef"},
+        {ExifInterface.TAG_GPS_VERSION_ID, "GPSVersionID"},
+        {ExifInterface.TAG_IMAGE_DESCRIPTION, "ImageDescription"},
+        {ExifInterface.TAG_IMAGE_LENGTH, "ImageLength"},
+        {ExifInterface.TAG_IMAGE_UNIQUE_ID, "ImageUniqueID"},
+        {ExifInterface.TAG_IMAGE_WIDTH, "ImageWidth"},
+        {ExifInterface.TAG_INTEROPERABILITY_INDEX, "InteroperabilityIndex"},
+        {ExifInterface.TAG_ISO_SPEED, "ISOSpeed"},
+        {ExifInterface.TAG_ISO_SPEED_LATITUDE_YYY, "ISOSpeedLatitudeyyy"},
+        {ExifInterface.TAG_ISO_SPEED_LATITUDE_ZZZ, "ISOSpeedLatitudezzz"},
+        {ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT, "JPEGInterchangeFormat"},
+        {ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH, "JPEGInterchangeFormatLength"},
+        {ExifInterface.TAG_LIGHT_SOURCE, "LightSource"},
+        {ExifInterface.TAG_MAKE, "Make"},
+        {ExifInterface.TAG_MAKER_NOTE, "MakerNote"},
+        {ExifInterface.TAG_MAX_APERTURE_VALUE, "MaxApertureValue"},
+        {ExifInterface.TAG_METERING_MODE, "MeteringMode"},
+        {ExifInterface.TAG_MODEL, "Model"},
+        {ExifInterface.TAG_NEW_SUBFILE_TYPE, "NewSubfileType"},
+        {ExifInterface.TAG_OECF, "OECF"},
+        {ExifInterface.TAG_OFFSET_TIME, "OffsetTime"},
+        {ExifInterface.TAG_OFFSET_TIME_DIGITIZED, "OffsetTimeDigitized"},
+        {ExifInterface.TAG_OFFSET_TIME_ORIGINAL, "OffsetTimeOriginal"},
+        {ExifInterface.TAG_ORF_ASPECT_FRAME, "ORFAspectFrame"},
+        {ExifInterface.TAG_ORF_PREVIEW_IMAGE_LENGTH, "ORFPreviewImageLength"},
+        {ExifInterface.TAG_ORF_PREVIEW_IMAGE_START, "ORFPreviewImageStart"},
+        {ExifInterface.TAG_ORF_THUMBNAIL_IMAGE, "ORFThumbnailImage"},
+        {ExifInterface.TAG_ORIENTATION, "Orientation"},
+        {ExifInterface.TAG_PHOTOMETRIC_INTERPRETATION, "PhotometricInterpretation"},
+        {ExifInterface.TAG_PIXEL_X_DIMENSION, "PixelXDimension"},
+        {ExifInterface.TAG_PIXEL_Y_DIMENSION, "PixelYDimension"},
+        {ExifInterface.TAG_PLANAR_CONFIGURATION, "PlanarConfiguration"},
+        {ExifInterface.TAG_PRIMARY_CHROMATICITIES, "PrimaryChromaticities"},
+        {ExifInterface.TAG_RECOMMENDED_EXPOSURE_INDEX, "RecommendedExposureIndex"},
+        {ExifInterface.TAG_REFERENCE_BLACK_WHITE, "ReferenceBlackWhite"},
+        {ExifInterface.TAG_RELATED_SOUND_FILE, "RelatedSoundFile"},
+        {ExifInterface.TAG_RESOLUTION_UNIT, "ResolutionUnit"},
+        {ExifInterface.TAG_ROWS_PER_STRIP, "RowsPerStrip"},
+        {ExifInterface.TAG_RW2_ISO, "RW2ISO"},
+        {ExifInterface.TAG_RW2_JPG_FROM_RAW, "RW2JpgFromRaw"},
+        {ExifInterface.TAG_RW2_SENSOR_BOTTOM_BORDER, "RW2SensorBottomBorder"},
+        {ExifInterface.TAG_RW2_SENSOR_LEFT_BORDER, "RW2SensorLeftBorder"},
+        {ExifInterface.TAG_RW2_SENSOR_RIGHT_BORDER, "RW2SensorRightBorder"},
+        {ExifInterface.TAG_RW2_SENSOR_TOP_BORDER, "RW2SensorTopBorder"},
+        {ExifInterface.TAG_SAMPLES_PER_PIXEL, "SamplesPerPixel"},
+        {ExifInterface.TAG_SATURATION, "Saturation"},
+        {ExifInterface.TAG_SCENE_CAPTURE_TYPE, "SceneCaptureType"},
+        {ExifInterface.TAG_SCENE_TYPE, "SceneType"},
+        {ExifInterface.TAG_SENSING_METHOD, "SensingMethod"},
+        {ExifInterface.TAG_SENSITIVITY_TYPE, "SensitivityType"},
+        {ExifInterface.TAG_SHARPNESS, "Sharpness"},
+        {ExifInterface.TAG_SHUTTER_SPEED_VALUE, "ShutterSpeedValue"},
+        {ExifInterface.TAG_SOFTWARE, "Software"},
+        {ExifInterface.TAG_SPATIAL_FREQUENCY_RESPONSE, "SpatialFrequencyResponse"},
+        {ExifInterface.TAG_SPECTRAL_SENSITIVITY, "SpectralSensitivity"},
+        {ExifInterface.TAG_STANDARD_OUTPUT_SENSITIVITY, "StandardOutputSensitivity"},
+        {ExifInterface.TAG_STRIP_BYTE_COUNTS, "StripByteCounts"},
+        {ExifInterface.TAG_STRIP_OFFSETS, "StripOffsets"},
+        {ExifInterface.TAG_SUBFILE_TYPE, "SubfileType"},
+        {ExifInterface.TAG_SUBJECT_AREA, "SubjectArea"},
+        {ExifInterface.TAG_SUBJECT_DISTANCE, "SubjectDistance"},
+        {ExifInterface.TAG_SUBJECT_DISTANCE_RANGE, "SubjectDistanceRange"},
+        {ExifInterface.TAG_SUBJECT_LOCATION, "SubjectLocation"},
+        {ExifInterface.TAG_SUBSEC_TIME, "SubSecTime"},
+        {ExifInterface.TAG_SUBSEC_TIME_DIGITIZED, "SubSecTimeDigitized"},
+        {ExifInterface.TAG_SUBSEC_TIME_ORIGINAL, "SubSecTimeOriginal"},
+        {ExifInterface.TAG_THUMBNAIL_IMAGE_LENGTH, "ThumbnailImageLength"},
+        {ExifInterface.TAG_THUMBNAIL_IMAGE_WIDTH, "ThumbnailImageWidth"},
+        {ExifInterface.TAG_TRANSFER_FUNCTION, "TransferFunction"},
+        {ExifInterface.TAG_USER_COMMENT, "UserComment"},
+        {ExifInterface.TAG_WHITE_BALANCE, "WhiteBalance"},
+        {ExifInterface.TAG_WHITE_POINT, "WhitePoint"},
+        {ExifInterface.TAG_X_RESOLUTION, "XResolution"},
+        {ExifInterface.TAG_Y_CB_CR_COEFFICIENTS, "YCbCrCoefficients"},
+        {ExifInterface.TAG_Y_CB_CR_POSITIONING, "YCbCrPositioning"},
+        {ExifInterface.TAG_Y_CB_CR_SUB_SAMPLING, "YCbCrSubSampling"},
+        {ExifInterface.TAG_Y_RESOLUTION, "YResolution"}
+    };
+
+    private byte[] writeExifToImageBytes(byte[] imageBytes, ExifInterface sourceExif) {
+        try {
+            // Create a temporary file to write the image with EXIF
+            File tempExifFile = File.createTempFile("temp_exif", ".jpg", context.getCacheDir());
+            
+            // Write the image bytes to temp file
+            java.io.FileOutputStream fos = new java.io.FileOutputStream(tempExifFile);
+            fos.write(imageBytes);
+            fos.close();
+            
+            // Create new ExifInterface for the temp file and copy all EXIF data
+            ExifInterface newExif = new ExifInterface(tempExifFile.getAbsolutePath());
+            
+            // Copy all EXIF attributes from source to new
+            for (String[] tag : EXIF_TAGS) {
+                String value = sourceExif.getAttribute(tag[0]);
+                if (value != null) {
+                    newExif.setAttribute(tag[0], value);
+                }
+            }
+            
+            // Save the EXIF data
+            newExif.saveAttributes();
+            
+            // Read the file back with EXIF embedded
+            byte[] result = new byte[(int) tempExifFile.length()];
+            java.io.FileInputStream fis = new java.io.FileInputStream(tempExifFile);
+            fis.read(result);
+            fis.close();
+            
+            // Clean up temp file
+            tempExifFile.delete();
+            
+            return result;
+        } catch (Exception e) {
+            Log.e(TAG, "writeExifToImageBytes: Error writing EXIF data", e);
+            return imageBytes; // Return original bytes if error
+        }
+    }
+
     public void captureSample(int quality) {
         Log.d(TAG, "captureSample: Starting sample capture with quality: " + quality);
 
@@ -430,7 +795,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();
@@ -466,7 +831,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) {
@@ -476,11 +841,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
                             ));
@@ -498,11 +863,10 @@ public class CameraXView implements LifecycleOwner {
         }
     }
 
-    public static ZoomFactors getZoomFactorsStatic(Context context) {
+    public static ZoomFactors getZoomFactorsStatic() {
         try {
             // For static method, return default zoom factors
             // We can try to detect if ultra-wide is available by checking device list
-            List<com.ahm.capacitor.camera.preview.model.CameraDevice> devices = getAvailableDevicesStatic(context);
 
             float minZoom = 1.0f;
             float maxZoom = 10.0f;
@@ -519,7 +883,7 @@ public class CameraXView implements LifecycleOwner {
 
     public ZoomFactors getZoomFactors() {
         if (camera == null) {
-            return getZoomFactorsStatic(context);
+            return getZoomFactorsStatic();
         }
 
         try {
@@ -546,8 +910,6 @@ public class CameraXView implements LifecycleOwner {
 
         try {
             float currentZoom = Objects.requireNonNull(camera.getCameraInfo().getZoomState().getValue()).getZoomRatio();
-            float minZoom = camera.getCameraInfo().getZoomState().getValue().getMinZoomRatio();
-            float maxZoom = camera.getCameraInfo().getZoomState().getValue().getMaxZoomRatio();
 
             // Determine device type based on zoom capabilities
             String deviceType = "wideAngle";
@@ -594,46 +956,6 @@ public class CameraXView implements LifecycleOwner {
         }
     }
 
-    private List<androidx.camera.core.CameraInfo> getAvailableCamerasForCurrentPosition() {
-        if (cameraProvider == null) {
-            Log.w(TAG, "getAvailableCamerasForCurrentPosition: cameraProvider is null");
-            return Collections.emptyList();
-        }
-
-        List<androidx.camera.core.CameraInfo> allCameras = cameraProvider.getAvailableCameraInfos();
-        List<androidx.camera.core.CameraInfo> sameFacingCameras = new ArrayList<>();
-
-        Log.d(TAG, "getAvailableCamerasForCurrentPosition: Total cameras available: " + allCameras.size());
-
-        // Determine current facing direction from the session config to avoid restricted API call
-        boolean isCurrentBack = "back".equals(sessionConfig.getPosition());
-        Log.d(TAG, "getAvailableCamerasForCurrentPosition: Looking for " + (isCurrentBack ? "back" : "front") + " cameras");
-
-        for (int i = 0; i < allCameras.size(); i++) {
-            androidx.camera.core.CameraInfo cameraInfo = allCameras.get(i);
-            boolean isCameraBack = isBackCamera(cameraInfo);
-            String cameraId = getCameraId(cameraInfo);
-
-            Log.d(TAG, "getAvailableCamerasForCurrentPosition: Camera " + i + " - ID: " + cameraId + ", isBack: " + isCameraBack);
-
-            try {
-                float minZoom = Objects.requireNonNull(cameraInfo.getZoomState().getValue()).getMinZoomRatio();
-                float maxZoom = cameraInfo.getZoomState().getValue().getMaxZoomRatio();
-                Log.d(TAG, "getAvailableCamerasForCurrentPosition: Camera " + i + " zoom range: " + minZoom + "-" + maxZoom);
-            } catch (Exception e) {
-                Log.w(TAG, "getAvailableCamerasForCurrentPosition: Cannot get zoom info for camera " + i + ": " + e.getMessage());
-            }
-
-            if (isCameraBack == isCurrentBack) {
-                sameFacingCameras.add(cameraInfo);
-                Log.d(TAG, "getAvailableCamerasForCurrentPosition: Added camera " + i + " (" + cameraId + ") to same-facing list");
-            }
-        }
-
-        Log.d(TAG, "getAvailableCamerasForCurrentPosition: Found " + sameFacingCameras.size() + " cameras for " + (isCurrentBack ? "back" : "front"));
-        return sameFacingCameras;
-    }
-
     public static List<Size> getSupportedPictureSizes(String facing) {
         List<Size> sizes = new ArrayList<>();
         try {
@@ -786,13 +1108,13 @@ public class CameraXView implements LifecycleOwner {
                     Log.d(TAG, "switchToDevice: Found matching CameraInfo for deviceId: " + deviceId);
                     final CameraInfo finalTarget = targetCameraInfo;
 
-                    CameraSelector newSelector = new CameraSelector.Builder()
+                    // This filter will receive a list of all cameras and must return the one we want.
+
+                    currentCameraSelector = new CameraSelector.Builder()
                         .addCameraFilter(cameras -> {
                             // This filter will receive a list of all cameras and must return the one we want.
                             return Collections.singletonList(finalTarget);
                         }).build();
-
-                    currentCameraSelector = newSelector;
                     currentDeviceId = deviceId;
                     bindCameraUseCases(); // Rebind with the new, highly specific selector
                 } else {
@@ -827,7 +1149,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
@@ -845,4 +1169,480 @@ 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) {
+            String[] ratios = sessionConfig.getAspectRatio().split(":");
+            // For camera, use portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
+            float ratio = Float.parseFloat(ratios[1]) / Float.parseFloat(ratios[0]);
+            if (sessionConfig.getWidth() > 0) {
+                layoutParams.height = (int) (sessionConfig.getWidth() / ratio);
+            } else if (sessionConfig.getHeight() > 0) {
+                layoutParams.width = (int) (sessionConfig.getHeight() * ratio);
+            }
+        }
+
+        previewView.setLayoutParams(layoutParams);
+
+        if (listener != null) {
+            listener.onCameraStarted(
+                sessionConfig.getWidth(),
+                sessionConfig.getHeight(),
+                sessionConfig.getX(),
+                sessionConfig.getY()
+            );
+        }
+    }
+
+    public String getAspectRatio() {
+        if (sessionConfig != null) {
+            return sessionConfig.getAspectRatio();
+        }
+        return "4:3";
+    }
+
+    public String getGridMode() {
+        if (sessionConfig != null) {
+            return sessionConfig.getGridMode();
+        }
+        return "none";
+    }
+
+    public void setAspectRatio(String aspectRatio) {
+        setAspectRatio(aspectRatio, null, null);
+    }
+    
+    public void setAspectRatio(String aspectRatio, Float x, Float y) {
+        setAspectRatio(aspectRatio, x, y, null);
+    }
+
+    public void setAspectRatio(String aspectRatio, Float x, Float y, Runnable callback) {
+        if (sessionConfig == null) {
+            if (callback != null) callback.run();
+            return;
+        }
+        
+        String currentAspectRatio = sessionConfig.getAspectRatio();
+        
+        // Don't restart camera if aspect ratio hasn't changed and no position specified
+        if (aspectRatio != null && aspectRatio.equals(currentAspectRatio) && x == null && y == null) {
+            Log.d(TAG, "setAspectRatio: Aspect ratio " + aspectRatio + " is already set and no position specified, skipping");
+            if (callback != null) callback.run();
+            return;
+        }
+        
+        String currentGridMode = sessionConfig.getGridMode();
+        Log.d(TAG, "setAspectRatio: Changing from " + currentAspectRatio + " to " + aspectRatio + 
+              (x != null && y != null ? " at position (" + x + ", " + y + ")" : " with auto-centering") +
+              ", preserving grid mode: " + currentGridMode);
+        
+        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,
+                currentGridMode
+        );
+        
+        // Update layout and rebind camera with new aspect ratio
+        if (isRunning && previewContainer != null) {
+            mainExecutor.execute(() -> {
+                // First update the UI layout
+                updatePreviewLayoutForAspectRatio(aspectRatio, x, y);
+                
+                // Then rebind the camera with new aspect ratio configuration
+                Log.d(TAG, "setAspectRatio: Rebinding camera with new aspect ratio: " + aspectRatio);
+                bindCameraUseCases();
+                
+                // Preserve grid mode and wait for completion
+                if (gridOverlayView != null) {
+                    gridOverlayView.post(() -> {
+                        Log.d(TAG, "setAspectRatio: Re-applying grid mode: " + currentGridMode);
+                        gridOverlayView.setGridMode(currentGridMode);
+                        
+                        // Wait one more frame for grid to be applied, then call callback
+                        if (callback != null) {
+                            gridOverlayView.post(callback);
+                        }
+                    });
+                } else {
+                    // No grid overlay, wait one frame for layout completion then call callback
+                    if (callback != null) {
+                        previewContainer.post(callback);
+                    }
+                }
+            });
+        } else {
+            if (callback != null) callback.run();
+        }
+    }
+
+    public void setGridMode(String gridMode) {
+        if (sessionConfig != null) {
+            Log.d(TAG, "setGridMode: Changing grid mode to: " + gridMode);
+            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(),
+                    sessionConfig.getAspectRatio(),
+                    gridMode
+            );
+
+            // Update the grid overlay immediately
+            if (gridOverlayView != null) {
+                gridOverlayView.post(() -> {
+                    Log.d(TAG, "setGridMode: Applying grid mode to overlay: " + gridMode);
+                    gridOverlayView.setGridMode(gridMode);
+                });
+            }
+        }
+    }
+
+    public int getPreviewX() {
+      if (previewContainer == null) return 0;
+      ViewGroup.LayoutParams layoutParams = previewContainer.getLayoutParams();
+      if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+        // Return position relative to WebView content (subtract insets)
+        int margin = ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
+        int leftInset = getWebViewLeftInset();
+        int result = margin - leftInset;
+        Log.d(TAG, "getPreviewX: leftMargin=" + margin + ", leftInset=" + leftInset + ", result=" + result);
+        return result;
+      }
+      return previewContainer.getLeft();
+    }
+    public int getPreviewY() {
+      if (previewContainer == null) return 0;
+      ViewGroup.LayoutParams layoutParams = previewContainer.getLayoutParams();
+      if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+        // Return position relative to WebView content (subtract insets)
+        int margin = ((ViewGroup.MarginLayoutParams) layoutParams).topMargin;
+        int topInset = getWebViewTopInset();
+        int result = margin - topInset;
+        Log.d(TAG, "getPreviewY: topMargin=" + margin + ", topInset=" + topInset + ", result=" + result);
+        return result;
+      }
+      return previewContainer.getTop();
+    }
+    public int getPreviewWidth() {
+      return previewContainer != null ? previewContainer.getWidth() : 0;
+    }
+    public int getPreviewHeight() {
+      return previewContainer != null ? previewContainer.getHeight() : 0;
+    }
+    public void setPreviewSize(int x, int y, int width, int height) {
+        setPreviewSize(x, y, width, height, null);
+    }
+
+    public void setPreviewSize(int x, int y, int width, int height, Runnable callback) {
+        if (previewContainer == null) {
+            if (callback != null) callback.run();
+            return;
+        }
+        
+        // Ensure this runs on the main UI thread
+        mainExecutor.execute(() -> {
+            ViewGroup.LayoutParams layoutParams = previewContainer.getLayoutParams();
+            if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+                ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) layoutParams;
+                
+                // Only add insets for positioning coordinates, not for full-screen sizes
+                int webViewTopInset = getWebViewTopInset();
+                int webViewLeftInset = getWebViewLeftInset();
+                
+                // Handle positioning - preserve current values if new values are not specified (negative)
+                if (x >= 0) {
+                    // Don't add insets if this looks like a calculated full-screen coordinate (x=0, y=0)
+                    if (x == 0 && y == 0) {
+                        params.leftMargin = x;
+                        Log.d(TAG, "setPreviewSize: Full-screen mode - keeping x=0 without insets");
+                    } else {
+                        params.leftMargin = x + webViewLeftInset;
+                        Log.d(TAG, "setPreviewSize: Positioned mode - x=" + x + " + inset=" + webViewLeftInset + " = " + (x + webViewLeftInset));
+                    }
+                }
+                if (y >= 0) {
+                    // Don't add insets if this looks like a calculated full-screen coordinate (x=0, y=0)
+                    if (x == 0 && y == 0) {
+                        params.topMargin = y;
+                        Log.d(TAG, "setPreviewSize: Full-screen mode - keeping y=0 without insets");
+                    } else {
+                        params.topMargin = y + webViewTopInset;
+                        Log.d(TAG, "setPreviewSize: Positioned mode - y=" + y + " + inset=" + webViewTopInset + " = " + (y + webViewTopInset));
+                    }
+                } 
+                if (width > 0) params.width = width;
+                if (height > 0) params.height = height;
+                
+                previewContainer.setLayoutParams(params);
+                previewContainer.requestLayout();
+                
+                Log.d(TAG, "setPreviewSize: Updated to " + params.width + "x" + params.height + " at (" + params.leftMargin + "," + params.topMargin + ")");
+                
+                // Update session config to reflect actual layout
+                if (sessionConfig != null) {
+                    String currentAspectRatio = sessionConfig.getAspectRatio();
+                    
+                    // Calculate aspect ratio from actual dimensions if both width and height are provided
+                    String calculatedAspectRatio = currentAspectRatio;
+                    if (params.width > 0 && params.height > 0) {
+                        // Always use larger dimension / smaller dimension for consistent comparison
+                        float ratio = Math.max(params.width, params.height) / (float) Math.min(params.width, params.height);
+                        // Standard ratios: 16:9 ≈ 1.778, 4:3 ≈ 1.333
+                        float ratio16_9 = 16f / 9f; // 1.778
+                        float ratio4_3 = 4f / 3f;   // 1.333
+                        
+                        // Determine closest standard aspect ratio
+                        if (Math.abs(ratio - ratio16_9) < Math.abs(ratio - ratio4_3)) {
+                            calculatedAspectRatio = "16:9";
+                        } else {
+                            calculatedAspectRatio = "4:3";
+                        }
+                        Log.d(TAG, "setPreviewSize: Calculated aspect ratio from " + params.width + "x" + params.height + " = " + calculatedAspectRatio + " (normalized ratio=" + ratio + ")");
+                    }
+                    
+                    sessionConfig = new CameraSessionConfiguration(
+                            sessionConfig.getDeviceId(),
+                            sessionConfig.getPosition(),
+                            params.leftMargin,
+                            params.topMargin,
+                            params.width,
+                            params.height,
+                            sessionConfig.getPaddingBottom(),
+                            sessionConfig.getToBack(),
+                            sessionConfig.getStoreToFile(),
+                            sessionConfig.getEnableOpacity(),
+                            sessionConfig.getEnableZoom(),
+                            sessionConfig.getDisableExifHeaderStripping(),
+                            sessionConfig.getDisableAudio(),
+                            sessionConfig.getZoomFactor(),
+                            calculatedAspectRatio,
+                            sessionConfig.getGridMode()
+                    );
+                    
+                    // If aspect ratio changed due to size update, rebind camera
+                    if (isRunning && !Objects.equals(currentAspectRatio, calculatedAspectRatio)) {
+                        Log.d(TAG, "setPreviewSize: Aspect ratio changed from " + currentAspectRatio + " to " + calculatedAspectRatio + ", rebinding camera");
+                        bindCameraUseCases();
+                        
+                        // Wait for camera rebinding to complete, then call callback
+                        if (callback != null) {
+                            previewContainer.post(() -> previewContainer.post(callback));
+                        }
+                    } else {
+                        // No camera rebinding needed, wait for layout to complete then call callback
+                        if (callback != null) {
+                            previewContainer.post(callback);
+                        }
+                    }
+                } else {
+                    // No sessionConfig, just wait for layout then call callback
+                    if (callback != null) {
+                        previewContainer.post(callback);
+                    }
+                }
+            } else {
+                Log.w(TAG, "setPreviewSize: Cannot set margins on layout params of type " + layoutParams.getClass().getSimpleName());
+                // Fallback: just set width and height if specified
+                if (width > 0) layoutParams.width = width;
+                if (height > 0) layoutParams.height = height;
+                previewContainer.setLayoutParams(layoutParams);
+                previewContainer.requestLayout();
+                
+                // Wait for layout then call callback
+                if (callback != null) {
+                    previewContainer.post(callback);
+                }
+            }
+        });
+    }
+    
+    private void updatePreviewLayoutForAspectRatio(String aspectRatio) {
+        updatePreviewLayoutForAspectRatio(aspectRatio, null, null);
+    }
+    
+    private void updatePreviewLayoutForAspectRatio(String aspectRatio, Float x, Float y) {
+        if (previewContainer == null || aspectRatio == null) return;
+        
+        // Parse aspect ratio
+        String[] ratios = aspectRatio.split(":");
+        if (ratios.length != 2) return;
+        
+        try {
+            // For camera, use portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
+            float ratio = Float.parseFloat(ratios[1]) / Float.parseFloat(ratios[0]);
+            
+            // Get available space from webview dimensions
+            int availableWidth = webView.getWidth();
+            int availableHeight = webView.getHeight();
+            
+            // Calculate position and size
+            int finalX, finalY, finalWidth, finalHeight;
+            
+            if (x != null && y != null) {
+                // Account for WebView insets from edge-to-edge support
+                int webViewTopInset = getWebViewTopInset();
+                int webViewLeftInset = getWebViewLeftInset();
+                
+                // Use provided coordinates with boundary checking, adjusted for insets
+                finalX = Math.max(0, Math.min(x.intValue() + webViewLeftInset, availableWidth));
+                finalY = Math.max(0, Math.min(y.intValue() + webViewTopInset, availableHeight));
+                
+                // Calculate maximum available space from the given position
+                int maxWidth = availableWidth - finalX;
+                int maxHeight = availableHeight - finalY;
+                
+                // Calculate optimal size while maintaining aspect ratio within available space
+                finalWidth = maxWidth;
+                finalHeight = (int) (maxWidth / ratio);
+                
+                if (finalHeight > maxHeight) {
+                    // Height constraint is tighter, fit by height
+                    finalHeight = maxHeight;
+                    finalWidth = (int) (maxHeight * ratio);
+                }
+                
+                // Ensure final position stays within bounds
+                finalX = Math.max(0, Math.min(finalX, availableWidth - finalWidth));
+                finalY = Math.max(0, Math.min(finalY, availableHeight - finalHeight));
+            } else {
+                // Auto-center the view
+                // Calculate size based on aspect ratio, using a reasonable base size
+                // Use 80% of available space to ensure aspect ratio differences are visible
+                int maxAvailableWidth = (int) (availableWidth * 0.8);
+                int maxAvailableHeight = (int) (availableHeight * 0.8);
+                
+                // Start with width-based calculation
+                finalWidth = maxAvailableWidth;
+                finalHeight = (int) (finalWidth / ratio);
+                
+                // If height exceeds available space, use height-based calculation
+                if (finalHeight > maxAvailableHeight) {
+                    finalHeight = maxAvailableHeight;
+                    finalWidth = (int) (finalHeight * ratio);
+                }
+                
+                // Center the view
+                finalX = (availableWidth - finalWidth) / 2;
+                finalY = (availableHeight - finalHeight) / 2;
+                
+                Log.d(TAG, "updatePreviewLayoutForAspectRatio: Auto-center mode - ratio=" + ratio + 
+                      ", calculated size=" + finalWidth + "x" + finalHeight + 
+                      ", available=" + availableWidth + "x" + availableHeight);
+            }
+            
+            // Update layout params
+            ViewGroup.LayoutParams currentParams = previewContainer.getLayoutParams();
+            if (currentParams instanceof ViewGroup.MarginLayoutParams) {
+                ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) currentParams;
+                params.width = finalWidth;
+                params.height = finalHeight;
+                params.leftMargin = finalX;
+                params.topMargin = finalY;
+                previewContainer.setLayoutParams(params);
+                previewContainer.requestLayout();
+                Log.d(TAG, "updatePreviewLayoutForAspectRatio: Updated to " + finalWidth + "x" + finalHeight + " at (" + finalX + "," + finalY + ")");
+            }
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "Invalid aspect ratio format: " + aspectRatio, e);
+        }
+    }
+    
+    private void updatePreviewLayout() {
+        if (previewContainer == null || sessionConfig == null) return;
+        
+        String aspectRatio = sessionConfig.getAspectRatio();
+        if (aspectRatio == null) return;
+        
+        updatePreviewLayoutForAspectRatio(aspectRatio);
+    }
+
+    private int getWebViewTopInset() {
+        try {
+            if (webView != null) {
+                ViewGroup.LayoutParams layoutParams = webView.getLayoutParams();
+                if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+                    return ((ViewGroup.MarginLayoutParams) layoutParams).topMargin;
+                }
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "Failed to get WebView top inset", e);
+        }
+        return 0;
+    }
+
+    private int getWebViewLeftInset() {
+        try {
+            if (webView != null) {
+                ViewGroup.LayoutParams layoutParams = webView.getLayoutParams();
+                if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+                    return ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
+                }
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "Failed to get WebView left inset", e);
+        }
+        return 0;
+    }
+
+    /**
+     * Get the current preview position and size in DP units (without insets)
+     */
+    public int[] getCurrentPreviewBounds() {
+        if (previewContainer == null) {
+            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;
+        
+        if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+            ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) layoutParams;
+            
+            // Remove insets to get original coordinates in DP
+            DisplayMetrics metrics = context.getResources().getDisplayMetrics();
+            float pixelRatio = metrics.density;
+            
+            int webViewTopInset = getWebViewTopInset();
+            int webViewLeftInset = getWebViewLeftInset();
+            
+            x = Math.max(0, (int) ((params.leftMargin - webViewLeftInset) / pixelRatio));
+            y = Math.max(0, (int) ((params.topMargin - webViewTopInset) / pixelRatio));
+            width = (int) (params.width / pixelRatio);
+            height = (int) (params.height / pixelRatio);
+        }
+        
+        return new int[]{x, y, width, height};
+    }
 }