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

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

@@ -1,24 +1,31 @@
 package com.ahm.capacitor.camera.preview;
 
 import android.content.Context;
-import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
-import android.graphics.Matrix;
+import android.graphics.Color;
+import android.graphics.Rect;
+import android.graphics.drawable.GradientDrawable;
 import android.hardware.camera2.CameraAccessException;
 import android.hardware.camera2.CameraCharacteristics;
 import android.hardware.camera2.CameraManager;
 import android.location.Location;
-import android.net.Uri;
+import android.media.MediaScannerConnection;
 import android.os.Build;
 import android.os.Environment;
 import android.util.Base64;
 import android.util.DisplayMetrics;
 import android.util.Log;
-import android.util.Rational;
 import android.util.Size;
+import android.view.MotionEvent;
+import android.view.View;
 import android.view.ViewGroup;
-import android.view.ViewGroup;
+import android.view.animation.AlphaAnimation;
+import android.view.animation.Animation;
+import android.view.animation.AnimationSet;
+import android.view.animation.AnimationUtils;
+import android.view.animation.ScaleAnimation;
+import android.webkit.WebView;
 import android.webkit.WebView;
 import android.widget.FrameLayout;
 import android.widget.FrameLayout;
@@ -31,15 +38,11 @@ import androidx.camera.core.Camera;
 import androidx.camera.core.CameraInfo;
 import androidx.camera.core.CameraSelector;
 import androidx.camera.core.FocusMeteringAction;
-import androidx.camera.core.FocusMeteringAction;
-import androidx.camera.core.FocusMeteringResult;
 import androidx.camera.core.FocusMeteringResult;
 import androidx.camera.core.ImageCapture;
 import androidx.camera.core.ImageCaptureException;
 import androidx.camera.core.ImageProxy;
 import androidx.camera.core.MeteringPoint;
-import androidx.camera.core.MeteringPoint;
-import androidx.camera.core.MeteringPointFactory;
 import androidx.camera.core.MeteringPointFactory;
 import androidx.camera.core.Preview;
 import androidx.camera.core.ResolutionInfo;
@@ -55,7 +58,6 @@ import androidx.lifecycle.Lifecycle;
 import androidx.lifecycle.LifecycleObserver;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LifecycleRegistry;
-import androidx.lifecycle.OnLifecycleEvent;
 import com.ahm.capacitor.camera.preview.model.CameraSessionConfiguration;
 import com.ahm.capacitor.camera.preview.model.LensInfo;
 import com.ahm.capacitor.camera.preview.model.ZoomFactors;
@@ -65,7 +67,6 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.nio.file.Files;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -100,6 +101,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   private PreviewView previewView;
   private GridOverlayView gridOverlayView;
   private FrameLayout previewContainer;
+  private View focusIndicatorView;
   private CameraSelector currentCameraSelector;
   private String currentDeviceId;
   private int currentFlashMode = ImageCapture.FLASH_MODE_OFF;
@@ -111,6 +113,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   private final Executor mainExecutor;
   private ExecutorService cameraExecutor;
   private boolean isRunning = false;
+  private Size currentPreviewResolution = null;
+  private ListenableFuture<FocusMeteringResult> currentFocusFuture = null; // Track current focus operation
 
   public CameraXView(Context context, WebView webView) {
     this.context = context;
@@ -139,6 +143,47 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
   private void saveImageToGallery(byte[] data) {
     try {
+      // Detect image format from byte array header
+      String extension = ".jpg";
+      String mimeType = "image/jpeg";
+
+      if (data.length >= 8) {
+        // Check for PNG signature (89 50 4E 47 0D 0A 1A 0A)
+        if (
+          data[0] == (byte) 0x89 &&
+          data[1] == 0x50 &&
+          data[2] == 0x4E &&
+          data[3] == 0x47
+        ) {
+          extension = ".png";
+          mimeType = "image/png";
+        }
+        // Check for JPEG signature (FF D8 FF)
+        else if (
+          data[0] == (byte) 0xFF &&
+          data[1] == (byte) 0xD8 &&
+          data[2] == (byte) 0xFF
+        ) {
+          extension = ".jpg";
+          mimeType = "image/jpeg";
+        }
+        // Check for WebP signature (RIFF ... WEBP)
+        else if (
+          data[0] == 0x52 &&
+          data[1] == 0x49 &&
+          data[2] == 0x46 &&
+          data[3] == 0x46 &&
+          data.length >= 12 &&
+          data[8] == 0x57 &&
+          data[9] == 0x45 &&
+          data[10] == 0x42 &&
+          data[11] == 0x50
+        ) {
+          extension = ".webp";
+          mimeType = "image/webp";
+        }
+      }
+
       File photo = new File(
         Environment.getExternalStoragePublicDirectory(
           Environment.DIRECTORY_PICTURES
@@ -147,19 +192,19 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(
           new java.util.Date()
         ) +
-        ".jpg"
+        extension
       );
       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
+      MediaScannerConnection.scanFile(
+        this.context,
+        new String[] { photo.getAbsolutePath() },
+        new String[] { mimeType },
+        null
       );
-      Uri contentUri = Uri.fromFile(photo);
-      mediaScanIntent.setData(contentUri);
-      context.sendBroadcast(mediaScanIntent);
     } catch (IOException e) {
       Log.e(TAG, "Error saving image to gallery", e);
     }
@@ -176,6 +221,12 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
   public void stopSession() {
     isRunning = false;
+    // Cancel any ongoing focus operation when stopping session
+    if (currentFocusFuture != null && !currentFocusFuture.isDone()) {
+      currentFocusFuture.cancel(true);
+    }
+    currentFocusFuture = null;
+
     mainExecutor.execute(() -> {
       if (cameraProvider != null) {
         cameraProvider.unbindAll();
@@ -219,10 +270,70 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     // Create a container to hold both the preview and grid overlay
     previewContainer = new FrameLayout(context);
+    // Ensure container can receive touch events
+    previewContainer.setClickable(true);
+    previewContainer.setFocusable(true);
 
     // Create and setup the preview view
     previewView = new PreviewView(context);
     previewView.setScaleType(PreviewView.ScaleType.FIT_CENTER);
+    // Also make preview view touchable as backup
+    previewView.setClickable(true);
+    previewView.setFocusable(true);
+
+    // Add touch listener to both container and preview view for maximum compatibility
+    View.OnTouchListener touchListener = new View.OnTouchListener() {
+      @Override
+      public boolean onTouch(View v, MotionEvent event) {
+        Log.d(
+          TAG,
+          "onTouch: " +
+          v.getClass().getSimpleName() +
+          " received touch event: " +
+          event.getAction() +
+          " at (" +
+          event.getX() +
+          ", " +
+          event.getY() +
+          ")"
+        );
+
+        if (event.getAction() == MotionEvent.ACTION_DOWN) {
+          float x = event.getX() / v.getWidth();
+          float y = event.getY() / v.getHeight();
+
+          Log.d(
+            TAG,
+            "onTouch: Touch detected at raw coords (" +
+            event.getX() +
+            ", " +
+            event.getY() +
+            "), view size: " +
+            v.getWidth() +
+            "x" +
+            v.getHeight() +
+            ", normalized: (" +
+            x +
+            ", " +
+            y +
+            ")"
+          );
+
+          try {
+            // Trigger focus with indicator
+            setFocus(x, y);
+          } catch (Exception e) {
+            Log.e(TAG, "Error during tap-to-focus: " + e.getMessage(), e);
+          }
+          return true;
+        }
+        return false;
+      }
+    };
+
+    previewContainer.setOnTouchListener(touchListener);
+    previewView.setOnTouchListener(touchListener);
+
     previewContainer.addView(
       previewView,
       new FrameLayout.LayoutParams(
@@ -233,6 +344,9 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     // Create and setup the grid overlay
     gridOverlayView = new GridOverlayView(context);
+    // Make grid overlay not intercept touch events
+    gridOverlayView.setClickable(false);
+    gridOverlayView.setFocusable(false);
     previewContainer.addView(
       gridOverlayView,
       new FrameLayout.LayoutParams(
@@ -252,6 +366,47 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       FrameLayout.LayoutParams layoutParams = calculatePreviewLayoutParams();
       parent.addView(previewContainer, layoutParams);
       if (sessionConfig.isToBack()) webView.bringToFront();
+
+      // Log the actual position after layout
+      previewContainer.post(() -> {
+        Log.d(TAG, "========================");
+        Log.d(TAG, "ACTUAL CAMERA VIEW POSITION (after layout):");
+        Log.d(
+          TAG,
+          "Container position - Left: " +
+          previewContainer.getLeft() +
+          ", Top: " +
+          previewContainer.getTop() +
+          ", Right: " +
+          previewContainer.getRight() +
+          ", Bottom: " +
+          previewContainer.getBottom()
+        );
+        Log.d(
+          TAG,
+          "Container size - Width: " +
+          previewContainer.getWidth() +
+          ", Height: " +
+          previewContainer.getHeight()
+        );
+
+        // Get parent info
+        ViewGroup containerParent = (ViewGroup) previewContainer.getParent();
+        if (containerParent != null) {
+          Log.d(
+            TAG,
+            "Parent class: " + containerParent.getClass().getSimpleName()
+          );
+          Log.d(
+            TAG,
+            "Parent size - Width: " +
+            containerParent.getWidth() +
+            ", Height: " +
+            containerParent.getHeight()
+          );
+        }
+        Log.d(TAG, "========================");
+      });
     }
   }
 
@@ -296,8 +451,52 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             optimalWidth = (int) (height * ratio);
           }
 
+          // Store the old dimensions to check if we need to recenter
+          int oldWidth = width;
+          int oldHeight = height;
           width = optimalWidth;
           height = optimalHeight;
+
+          // If we're centered and dimensions changed, recalculate position
+          if (sessionConfig.isCentered()) {
+            DisplayMetrics metrics = context.getResources().getDisplayMetrics();
+
+            if (width != oldWidth) {
+              int screenWidth = metrics.widthPixels;
+              x = (screenWidth - width) / 2;
+              Log.d(
+                TAG,
+                "calculatePreviewLayoutParams: Recentered X after aspect ratio - " +
+                "oldWidth=" +
+                oldWidth +
+                ", newWidth=" +
+                width +
+                ", screenWidth=" +
+                screenWidth +
+                ", newX=" +
+                x
+              );
+            }
+
+            if (height != oldHeight) {
+              int screenHeight = metrics.heightPixels;
+              // Always center based on full screen height
+              y = (screenHeight - height) / 2;
+              Log.d(
+                TAG,
+                "calculatePreviewLayoutParams: Recentered Y after aspect ratio - " +
+                "oldHeight=" +
+                oldHeight +
+                ", newHeight=" +
+                height +
+                ", screenHeight=" +
+                screenHeight +
+                ", newY=" +
+                y
+              );
+            }
+          }
+
           Log.d(
             TAG,
             "calculatePreviewLayoutParams: Applied aspect ratio " +
@@ -318,41 +517,22 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       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"
-      );
-    }
+    // The X and Y positions passed from CameraPreview already include webView insets
+    // when edge-to-edge is active, so we don't need to add them again here
+    layoutParams.leftMargin = x;
+    layoutParams.topMargin = y;
 
     Log.d(
       TAG,
-      "calculatePreviewLayoutParams: Applied insets - x:" +
+      "calculatePreviewLayoutParams: Position calculation - x:" +
       x +
-      "+" +
-      webViewLeftInset +
-      "=" +
+      " (leftMargin=" +
       layoutParams.leftMargin +
-      ", y:" +
+      "), y:" +
       y +
-      "+" +
-      webViewTopInset +
-      "=" +
-      layoutParams.topMargin
+      " (topMargin=" +
+      layoutParams.topMargin +
+      ")"
     );
 
     Log.d(
@@ -383,6 +563,9 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     if (gridOverlayView != null) {
       gridOverlayView = null;
     }
+    if (focusIndicatorView != null) {
+      focusIndicatorView = null;
+    }
     webView.setBackgroundColor(android.graphics.Color.WHITE);
   }
 
@@ -487,10 +670,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         // Log resolution info
         ResolutionInfo previewResolution = preview.getResolutionInfo();
         if (previewResolution != null) {
-          Log.d(
-            TAG,
-            "Preview resolution: " + previewResolution.getResolution()
-          );
+          currentPreviewResolution = previewResolution.getResolution();
+          Log.d(TAG, "Preview resolution: " + currentPreviewResolution);
         }
         ResolutionInfo imageCaptureResolution =
           imageCapture.getResolutionInfo();
@@ -508,6 +689,28 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           : sessionConfig.getZoomFactor();
         if (initialZoom != 1.0f) {
           Log.d(TAG, "Applying initial zoom of " + initialZoom);
+
+          // Validate zoom is within bounds
+          if (zoomState != null) {
+            float minZoom = zoomState.getMinZoomRatio();
+            float maxZoom = zoomState.getMaxZoomRatio();
+
+            if (initialZoom < minZoom || initialZoom > maxZoom) {
+              if (listener != null) {
+                listener.onCameraStartError(
+                  "Initial zoom level " +
+                  initialZoom +
+                  " is not available. " +
+                  "Valid range is " +
+                  minZoom +
+                  " to " +
+                  maxZoom
+                );
+                return;
+              }
+            }
+          }
+
           setZoomInternal(initialZoom);
         }
 
@@ -517,18 +720,24 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           // 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();
+            // Get the actual camera dimensions and position
+            int actualWidth = getPreviewWidth();
+            int actualHeight = getPreviewHeight();
+            int actualX = getPreviewX();
+            int actualY = getPreviewY();
+
+            Log.d(
+              TAG,
+              "onCameraStarted callback - actualX=" +
+              actualX +
+              ", actualY=" +
+              actualY +
+              ", actualWidth=" +
+              actualWidth +
+              ", actualHeight=" +
+              actualHeight
+            );
+
             listener.onCameraStarted(
               actualWidth,
               actualHeight,
@@ -615,9 +824,18 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     final boolean saveToGallery,
     Integer width,
     Integer height,
+    String aspectRatio,
     Location location
   ) {
-    Log.d(TAG, "capturePhoto: Starting photo capture with quality: " + quality);
+    Log.d(TAG, "capturePhoto: Starting photo capture with quality: " + quality + ", aspectRatio: " + aspectRatio);
+
+    // Check for conflicting parameters
+    if (aspectRatio != null && (width != null || height != null)) {
+      if (listener != null) {
+        listener.onPictureTakenError("Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start.");
+      }
+      return;
+    }
 
     if (imageCapture == null) {
       if (listener != null) {
@@ -665,7 +883,63 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
             JSONObject exifData = getExifData(exifInterface);
 
-            if (width != null && height != null) {
+            // Handle aspect ratio if no width/height specified
+            if (width == null && height == null && aspectRatio != null && !aspectRatio.isEmpty()) {
+              // Get the original image dimensions
+              Bitmap originalBitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+              int originalWidth = originalBitmap.getWidth();
+              int originalHeight = originalBitmap.getHeight();
+              
+              // Parse aspect ratio
+              String[] ratios = aspectRatio.split(":");
+              if (ratios.length == 2) {
+                try {
+                  float widthRatio = Float.parseFloat(ratios[0]);
+                  float heightRatio = Float.parseFloat(ratios[1]);
+                  
+                  // For capture in portrait orientation, swap the aspect ratio (16:9 becomes 9:16)
+                  boolean isPortrait = originalHeight > originalWidth;
+                  float targetAspectRatio = isPortrait ? heightRatio / widthRatio : widthRatio / heightRatio;
+                  float originalAspectRatio = (float) originalWidth / originalHeight;
+                  
+                  int targetWidth, targetHeight;
+                  
+                  if (originalAspectRatio > targetAspectRatio) {
+                    // Original is wider than target - fit by height
+                    targetHeight = originalHeight;
+                    targetWidth = (int) (targetHeight * targetAspectRatio);
+                  } else {
+                    // Original is taller than target - fit by width
+                    targetWidth = originalWidth;
+                    targetHeight = (int) (targetWidth / targetAspectRatio);
+                  }
+                  
+                  // Center crop the image
+                  int xOffset = (originalWidth - targetWidth) / 2;
+                  int yOffset = (originalHeight - targetHeight) / 2;
+                  
+                  Bitmap croppedBitmap = Bitmap.createBitmap(
+                    originalBitmap,
+                    xOffset,
+                    yOffset,
+                    targetWidth,
+                    targetHeight
+                  );
+                  
+                  ByteArrayOutputStream stream = new ByteArrayOutputStream();
+                  croppedBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream);
+                  bytes = stream.toByteArray();
+                  
+                  // Write EXIF data back to cropped image
+                  bytes = writeExifToImageBytes(bytes, exifInterface);
+                  
+                  originalBitmap.recycle();
+                  croppedBitmap.recycle();
+                } catch (NumberFormatException e) {
+                  Log.e(TAG, "Invalid aspect ratio format: " + aspectRatio, e);
+                }
+              }
+            } else if (width != null && height != null) {
               Bitmap bitmap = BitmapFactory.decodeByteArray(
                 bytes,
                 0,
@@ -1262,7 +1536,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     }
   }
 
-  public void setZoom(float zoomRatio) throws Exception {
+  public void setZoom(float zoomRatio, boolean autoFocus) throws Exception {
     if (camera == null) {
       throw new Exception("Camera not initialized");
     }
@@ -1281,6 +1555,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           try {
             zoomFuture.get();
             Log.d(TAG, "Zoom successfully set to " + zoomRatio);
+            // Trigger autofocus after zoom if requested
+            if (autoFocus) {
+              triggerAutoFocus();
+            }
           } catch (Exception e) {
             Log.e(TAG, "Error setting zoom: " + e.getMessage());
           }
@@ -1298,11 +1576,35 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       throw new Exception("Camera not initialized");
     }
 
-    Log.d(TAG, "setFocus: Setting focus at (" + x + ", " + y + ")");
+    if (previewView == null) {
+      throw new Exception("Preview view not initialized");
+    }
+
+    // Validate that coordinates are within bounds (0-1 range)
+    if (x < 0f || x > 1f || y < 0f || y > 1f) {
+      Log.w(TAG, "setFocus: Coordinates out of bounds - x: " + x + ", y: " + y);
+      throw new Exception("Focus coordinates must be between 0 and 1");
+    }
+
+    // Cancel any ongoing focus operation
+    if (currentFocusFuture != null && !currentFocusFuture.isDone()) {
+      Log.d(TAG, "setFocus: Cancelling previous focus operation");
+      currentFocusFuture.cancel(true);
+    }
 
-    // Convert normalized coordinates (0-1) to view coordinates
     int viewWidth = previewView.getWidth();
     int viewHeight = previewView.getHeight();
+    
+    if (viewWidth <= 0 || viewHeight <= 0) {
+      throw new Exception(
+        "Preview view has invalid dimensions: " + viewWidth + "x" + viewHeight
+      );
+    }
+
+    // Only show focus indicator after validation passes
+    float indicatorX = x * viewWidth;
+    float indicatorY = y * viewHeight;
+    showFocusIndicator(indicatorX, indicatorY);
 
     // Create MeteringPoint using the preview view
     MeteringPointFactory factory = previewView.getMeteringPointFactory();
@@ -1317,27 +1619,252 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       .build();
 
     try {
-      ListenableFuture<FocusMeteringResult> focusFuture = camera
+      currentFocusFuture = camera
         .getCameraControl()
         .startFocusAndMetering(action);
 
-      focusFuture.addListener(
+      currentFocusFuture.addListener(
         () -> {
           try {
-            FocusMeteringResult result = focusFuture.get();
-            Log.d(TAG, "Focus result: " + result.isFocusSuccessful());
+            FocusMeteringResult result = currentFocusFuture.get();
           } catch (Exception e) {
-            Log.e(TAG, "Error during focus: " + e.getMessage());
+            // Handle cancellation gracefully - this is expected when rapid taps occur
+            if (
+              e.getMessage() != null &&
+              (e
+                  .getMessage()
+                  .contains("Cancelled by another startFocusAndMetering") ||
+                e.getMessage().contains("OperationCanceledException") ||
+                e
+                  .getClass()
+                  .getSimpleName()
+                  .contains("OperationCanceledException"))
+            ) {
+              Log.d(
+                TAG,
+                "Focus operation was cancelled by a newer focus request"
+              );
+            } else {
+              Log.e(TAG, "Error during focus: " + e.getMessage());
+            }
+          } finally {
+            // Clear the reference if this is still the current operation
+            if (currentFocusFuture != null && currentFocusFuture.isDone()) {
+              currentFocusFuture = null;
+            }
           }
         },
         ContextCompat.getMainExecutor(context)
       );
     } catch (Exception e) {
+      currentFocusFuture = null;
       Log.e(TAG, "Failed to set focus: " + e.getMessage());
       throw e;
     }
   }
 
+  private void showFocusIndicator(float x, float y) {
+    if (previewContainer == null) {
+      Log.w(TAG, "showFocusIndicator: previewContainer is null");
+      return;
+    }
+
+    // Check if container has been laid out
+    if (previewContainer.getWidth() == 0 || previewContainer.getHeight() == 0) {
+      Log.w(
+        TAG,
+        "showFocusIndicator: previewContainer not laid out yet, posting to run after layout"
+      );
+      previewContainer.post(() -> showFocusIndicator(x, y));
+      return;
+    }
+
+    // Remove any existing focus indicator
+    if (focusIndicatorView != null) {
+      previewContainer.removeView(focusIndicatorView);
+      focusIndicatorView = null;
+    }
+
+    // Create an elegant focus indicator
+    View container = new View(context);
+    int size = (int) (60 * context.getResources().getDisplayMetrics().density); // 60dp size
+    FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(size, size);
+
+    // Center the indicator on the touch point with bounds checking
+    int containerWidth = previewContainer.getWidth();
+    int containerHeight = previewContainer.getHeight();
+
+    params.leftMargin = Math.max(
+      0,
+      Math.min((int) (x - size / 2), containerWidth - size)
+    );
+    params.topMargin = Math.max(
+      0,
+      Math.min((int) (y - size / 2), containerHeight - size)
+    );
+
+    // Create an elegant focus ring - white stroke with transparent center
+    GradientDrawable drawable = new GradientDrawable();
+    drawable.setShape(GradientDrawable.OVAL);
+    drawable.setStroke(
+      (int) (2 * context.getResources().getDisplayMetrics().density),
+      Color.WHITE
+    ); // 2dp white stroke
+    drawable.setColor(Color.TRANSPARENT); // Transparent center
+    container.setBackground(drawable);
+
+    focusIndicatorView = container;
+
+    // Set initial state for smooth animation
+    focusIndicatorView.setAlpha(1f); // Start visible
+    focusIndicatorView.setScaleX(1.8f); // Start larger for scale-in effect
+    focusIndicatorView.setScaleY(1.8f);
+    focusIndicatorView.setVisibility(View.VISIBLE);
+
+    // Ensure container doesn't intercept touch events
+    container.setClickable(false);
+    container.setFocusable(false);
+
+    // Ensure the focus indicator has a high elevation for visibility
+    if (
+      android.os.Build.VERSION.SDK_INT >=
+      android.os.Build.VERSION_CODES.LOLLIPOP
+    ) {
+      focusIndicatorView.setElevation(10f);
+    }
+
+    // Add to container first
+    previewContainer.addView(focusIndicatorView, params);
+
+    // Fix z-ordering: ensure focus indicator is always on top
+    focusIndicatorView.bringToFront();
+
+    // Force a layout pass to ensure the view is properly positioned
+    previewContainer.requestLayout();
+
+    // Smooth scale down animation with easing (no fade needed since we start visible)
+    ScaleAnimation scaleAnimation = new ScaleAnimation(
+      1.8f,
+      1.0f,
+      1.8f,
+      1.0f,
+      Animation.RELATIVE_TO_SELF,
+      0.5f,
+      Animation.RELATIVE_TO_SELF,
+      0.5f
+    );
+    scaleAnimation.setDuration(300);
+    scaleAnimation.setInterpolator(
+      new android.view.animation.OvershootInterpolator(1.2f)
+    );
+
+    // Start the animation
+    focusIndicatorView.startAnimation(scaleAnimation);
+
+    // Schedule fade out and removal with smoother timing
+    focusIndicatorView.postDelayed(
+      new Runnable() {
+        @Override
+        public void run() {
+          if (focusIndicatorView != null) {
+            // Smooth fade to semi-transparent
+            AlphaAnimation fadeToTransparent = new AlphaAnimation(1f, 0.4f);
+            fadeToTransparent.setDuration(400);
+            fadeToTransparent.setInterpolator(
+              new android.view.animation.AccelerateInterpolator()
+            );
+
+            fadeToTransparent.setAnimationListener(
+              new Animation.AnimationListener() {
+                @Override
+                public void onAnimationStart(Animation animation) {
+                  Log.d(TAG, "showFocusIndicator: Fade to transparent started");
+                }
+
+                @Override
+                public void onAnimationEnd(Animation animation) {
+                  Log.d(
+                    TAG,
+                    "showFocusIndicator: Fade to transparent ended, starting final fade out"
+                  );
+                  // Final smooth fade out and scale down
+                  if (focusIndicatorView != null) {
+                    AnimationSet finalAnimation = new AnimationSet(false);
+
+                    AlphaAnimation finalFadeOut = new AlphaAnimation(0.4f, 0f);
+                    finalFadeOut.setDuration(500);
+                    finalFadeOut.setStartOffset(300);
+                    finalFadeOut.setInterpolator(
+                      new android.view.animation.AccelerateInterpolator()
+                    );
+
+                    ScaleAnimation finalScaleDown = new ScaleAnimation(
+                      1.0f,
+                      0.9f,
+                      1.0f,
+                      0.9f,
+                      Animation.RELATIVE_TO_SELF,
+                      0.5f,
+                      Animation.RELATIVE_TO_SELF,
+                      0.5f
+                    );
+                    finalScaleDown.setDuration(500);
+                    finalScaleDown.setStartOffset(300);
+                    finalScaleDown.setInterpolator(
+                      new android.view.animation.AccelerateInterpolator()
+                    );
+
+                    finalAnimation.addAnimation(finalFadeOut);
+                    finalAnimation.addAnimation(finalScaleDown);
+
+                    finalAnimation.setAnimationListener(
+                      new Animation.AnimationListener() {
+                        @Override
+                        public void onAnimationStart(Animation animation) {
+                          Log.d(
+                            TAG,
+                            "showFocusIndicator: Final animation started"
+                          );
+                        }
+
+                        @Override
+                        public void onAnimationEnd(Animation animation) {
+                          Log.d(
+                            TAG,
+                            "showFocusIndicator: Final animation ended, removing indicator"
+                          );
+                          // Remove the focus indicator
+                          if (
+                            focusIndicatorView != null &&
+                            previewContainer != null
+                          ) {
+                            previewContainer.removeView(focusIndicatorView);
+                            focusIndicatorView = null;
+                          }
+                        }
+
+                        @Override
+                        public void onAnimationRepeat(Animation animation) {}
+                      }
+                    );
+
+                    focusIndicatorView.startAnimation(finalAnimation);
+                  }
+                }
+
+                @Override
+                public void onAnimationRepeat(Animation animation) {}
+              }
+            );
+
+            focusIndicatorView.startAnimation(fadeToTransparent);
+          }
+        }
+      },
+      800
+    ); // Optimal timing for smooth focus feedback
+  }
+
   public static List<Size> getSupportedPictureSizes(String facing) {
     List<Size> sizes = new ArrayList<>();
     try {
@@ -1800,54 +2327,138 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
   public int getPreviewX() {
     if (previewContainer == null) return 0;
+
+    // Get the container position
     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;
+      int containerX = ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
+
+      // Get the actual camera bounds within the container
+      Rect cameraBounds = getActualCameraBounds();
+      int actualX = containerX + cameraBounds.left;
+
       Log.d(
         TAG,
-        "getPreviewX: leftMargin=" +
-        margin +
-        ", leftInset=" +
-        leftInset +
-        ", result=" +
-        result
+        "getPreviewX: containerX=" +
+        containerX +
+        ", cameraBounds.left=" +
+        cameraBounds.left +
+        ", actualX=" +
+        actualX
       );
-      return result;
+
+      return actualX;
     }
     return previewContainer.getLeft();
   }
 
   public int getPreviewY() {
     if (previewContainer == null) return 0;
+
+    // Get the container position
     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;
+      int containerY = ((ViewGroup.MarginLayoutParams) layoutParams).topMargin;
+
+      // Get the actual camera bounds within the container
+      Rect cameraBounds = getActualCameraBounds();
+      int actualY = containerY + cameraBounds.top;
+
       Log.d(
         TAG,
-        "getPreviewY: topMargin=" +
-        margin +
-        ", topInset=" +
-        topInset +
-        ", result=" +
-        result
+        "getPreviewY: containerY=" +
+        containerY +
+        ", cameraBounds.top=" +
+        cameraBounds.top +
+        ", actualY=" +
+        actualY
       );
-      return result;
+
+      return actualY;
     }
     return previewContainer.getTop();
   }
 
+  // Get the actual camera content bounds within the PreviewView
+  private Rect getActualCameraBounds() {
+    if (previewView == null || previewContainer == null) {
+      return new Rect(0, 0, 0, 0);
+    }
+
+    // Get the container bounds
+    int containerWidth = previewContainer.getWidth();
+    int containerHeight = previewContainer.getHeight();
+
+    // Get the preview transformation info to understand how the camera is scaled/positioned
+    // For FIT_CENTER, the camera content is scaled to fit within the container
+    // This might create letterboxing (black bars) on top/bottom or left/right
+
+    // Get the actual preview resolution
+    if (currentPreviewResolution == null) {
+      // If we don't have the resolution yet, assume the container is filled
+      return new Rect(0, 0, containerWidth, containerHeight);
+    }
+
+    // The preview is rotated 90 degrees for portrait mode
+    // So we swap the dimensions
+    int cameraWidth = currentPreviewResolution.getHeight();
+    int cameraHeight = currentPreviewResolution.getWidth();
+
+    // Calculate the scaling factor to fit the camera in the container
+    float widthScale = (float) containerWidth / cameraWidth;
+    float heightScale = (float) containerHeight / cameraHeight;
+    float scale = Math.min(widthScale, heightScale); // FIT_CENTER uses min scale
+
+    // Calculate the actual size of the camera content after scaling
+    int scaledWidth = Math.round(cameraWidth * scale);
+    int scaledHeight = Math.round(cameraHeight * scale);
+
+    // Calculate the offset to center the content
+    int offsetX = (containerWidth - scaledWidth) / 2;
+    int offsetY = (containerHeight - scaledHeight) / 2;
+
+    Log.d(
+      TAG,
+      "getActualCameraBounds: container=" +
+      containerWidth +
+      "x" +
+      containerHeight +
+      ", camera=" +
+      cameraWidth +
+      "x" +
+      cameraHeight +
+      ", scale=" +
+      scale +
+      ", scaled=" +
+      scaledWidth +
+      "x" +
+      scaledHeight +
+      ", offset=(" +
+      offsetX +
+      "," +
+      offsetY +
+      ")"
+    );
+
+    // Return the bounds relative to the container
+    return new Rect(
+      offsetX,
+      offsetY,
+      offsetX + scaledWidth,
+      offsetY + scaledHeight
+    );
+  }
+
   public int getPreviewWidth() {
-    return previewContainer != null ? previewContainer.getWidth() : 0;
+    if (previewContainer == null) return 0;
+    Rect bounds = getActualCameraBounds();
+    return bounds.width();
   }
 
   public int getPreviewHeight() {
-    return previewContainer != null ? previewContainer.getHeight() : 0;
+    if (previewContainer == null) return 0;
+    Rect bounds = getActualCameraBounds();
+    return bounds.height();
   }
 
   public void setPreviewSize(int x, int y, int width, int height) {
@@ -2167,22 +2778,13 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     }
   }
 
-  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;
-        }
+        // Get the actual WebView position on screen
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        return location[1]; // Y position is the top inset
       }
     } catch (Exception e) {
       Log.w(TAG, "Failed to get WebView top inset", e);
@@ -2193,10 +2795,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   private int getWebViewLeftInset() {
     try {
       if (webView != null) {
-        ViewGroup.LayoutParams layoutParams = webView.getLayoutParams();
-        if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
-          return ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
-        }
+        // Get the actual WebView position on screen for consistency
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        return location[0]; // X position is the left inset
       }
     } catch (Exception e) {
       Log.w(TAG, "Failed to get WebView left inset", e);
@@ -2212,32 +2814,112 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       return new int[] { 0, 0, 0, 0 }; // x, y, width, height
     }
 
-    ViewGroup.LayoutParams layoutParams = previewContainer.getLayoutParams();
-    int x = 0, y = 0, width = 0, height = 0;
+    // Get actual camera preview bounds (accounts for letterboxing/pillarboxing)
+    int actualX = getPreviewX();
+    int actualY = getPreviewY();
+    int actualWidth = getPreviewWidth();
+    int actualHeight = getPreviewHeight();
 
-    if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
-      ViewGroup.MarginLayoutParams params =
-        (ViewGroup.MarginLayoutParams) layoutParams;
+    // Convert to logical pixels for JavaScript
+    DisplayMetrics metrics = context.getResources().getDisplayMetrics();
+    float pixelRatio = metrics.density;
 
-      // Remove insets to get original coordinates in DP
-      DisplayMetrics metrics = context.getResources().getDisplayMetrics();
-      float pixelRatio = metrics.density;
+    // Remove WebView insets from coordinates
+    int webViewTopInset = getWebViewTopInset();
+    int webViewLeftInset = getWebViewLeftInset();
 
-      int webViewTopInset = getWebViewTopInset();
-      int webViewLeftInset = getWebViewLeftInset();
+    int x = Math.max(
+      0,
+      (int) ((actualX - webViewLeftInset) / pixelRatio)
+    );
+    int y = Math.max(
+      0,
+      (int) ((actualY - webViewTopInset) / pixelRatio)
+    );
+    int width = (int) (actualWidth / pixelRatio);
+    int height = (int) (actualHeight / pixelRatio);
 
-      x = Math.max(
-        0,
-        (int) ((params.leftMargin - webViewLeftInset) / pixelRatio)
-      );
-      y = Math.max(
-        0,
-        (int) ((params.topMargin - webViewTopInset) / pixelRatio)
-      );
-      width = (int) (params.width / pixelRatio);
-      height = (int) (params.height / pixelRatio);
+    return new int[] { x, y, width, height };
+  }
+
+  private void triggerAutoFocus() {
+    if (camera == null) {
+      return;
     }
 
-    return new int[] { x, y, width, height };
+    Log.d(TAG, "triggerAutoFocus: Triggering autofocus at center");
+
+    // Cancel any ongoing focus operation
+    if (currentFocusFuture != null && !currentFocusFuture.isDone()) {
+      Log.d(TAG, "triggerAutoFocus: Cancelling previous focus operation");
+      currentFocusFuture.cancel(true);
+    }
+
+    // Focus on the center of the view
+    int viewWidth = previewView.getWidth();
+    int viewHeight = previewView.getHeight();
+
+    if (viewWidth == 0 || viewHeight == 0) {
+      return;
+    }
+
+    // Create MeteringPoint at the center of the preview
+    MeteringPointFactory factory = previewView.getMeteringPointFactory();
+    MeteringPoint point = factory.createPoint(viewWidth / 2f, viewHeight / 2f);
+
+    // Create focus and metering action
+    FocusMeteringAction action = new FocusMeteringAction.Builder(
+      point,
+      FocusMeteringAction.FLAG_AF | FocusMeteringAction.FLAG_AE
+    )
+      .setAutoCancelDuration(3, TimeUnit.SECONDS) // Auto-cancel after 3 seconds
+      .build();
+
+    try {
+      currentFocusFuture = camera
+        .getCameraControl()
+        .startFocusAndMetering(action);
+      currentFocusFuture.addListener(
+        () -> {
+          try {
+            FocusMeteringResult result = currentFocusFuture.get();
+            Log.d(
+              TAG,
+              "triggerAutoFocus: Focus completed successfully: " +
+              result.isFocusSuccessful()
+            );
+          } catch (Exception e) {
+            // Handle cancellation gracefully - this is expected when rapid operations occur
+            if (
+              e.getMessage() != null &&
+              (e
+                  .getMessage()
+                  .contains("Cancelled by another startFocusAndMetering") ||
+                e.getMessage().contains("OperationCanceledException") ||
+                e
+                  .getClass()
+                  .getSimpleName()
+                  .contains("OperationCanceledException"))
+            ) {
+              Log.d(
+                TAG,
+                "triggerAutoFocus: Auto-focus was cancelled by a newer focus request"
+              );
+            } else {
+              Log.e(TAG, "triggerAutoFocus: Error during focus", e);
+            }
+          } finally {
+            // Clear the reference if this is still the current operation
+            if (currentFocusFuture != null && currentFocusFuture.isDone()) {
+              currentFocusFuture = null;
+            }
+          }
+        },
+        ContextCompat.getMainExecutor(context)
+      );
+    } catch (Exception e) {
+      currentFocusFuture = null;
+      Log.e(TAG, "triggerAutoFocus: Failed to trigger autofocus", e);
+    }
   }
 }