@capgo/camera-preview 7.14.8 → 7.15.0

package/android/src/main/java/{com/ahm → app/capgo}/capacitor/camera/preview/CameraXView.java

@@ -1,12 +1,13 @@
-package com.ahm.capacitor.camera.preview;
-
-import static androidx.core.content.ContextCompat.getSystemService;
+package app.capgo.capacitor.camera.preview;
 
+import android.Manifest;
 import android.content.Context;
+import android.content.pm.PackageManager;
 import android.content.res.Configuration;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Color;
+import android.graphics.Matrix;
 import android.graphics.Rect;
 import android.graphics.drawable.GradientDrawable;
 import android.hardware.camera2.CameraAccessException;
@@ -23,7 +24,6 @@ import android.util.Log;
 import android.util.Range;
 import android.util.Rational;
 import android.util.Size;
-import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowManager;
@@ -32,7 +32,6 @@ import android.webkit.WebView;
 import android.widget.FrameLayout;
 import androidx.annotation.NonNull;
 import androidx.annotation.OptIn;
-import androidx.annotation.RequiresApi;
 import androidx.camera.camera2.interop.Camera2CameraControl;
 import androidx.camera.camera2.interop.Camera2CameraInfo;
 import androidx.camera.camera2.interop.CaptureRequestOptions;
@@ -52,7 +51,6 @@ import androidx.camera.core.MeteringPointFactory;
 import androidx.camera.core.Preview;
 import androidx.camera.core.ResolutionInfo;
 import androidx.camera.core.TorchState;
-import androidx.camera.core.UseCase;
 import androidx.camera.core.ZoomState;
 import androidx.camera.core.resolutionselector.AspectRatioStrategy;
 import androidx.camera.core.resolutionselector.ResolutionSelector;
@@ -67,16 +65,18 @@ import androidx.camera.video.Recording;
 import androidx.camera.video.VideoCapture;
 import androidx.camera.video.VideoRecordEvent;
 import androidx.camera.view.PreviewView;
+import androidx.core.app.ActivityCompat;
 import androidx.core.content.ContextCompat;
 import androidx.exifinterface.media.ExifInterface;
 import androidx.lifecycle.Lifecycle;
 import androidx.lifecycle.LifecycleObserver;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LifecycleRegistry;
-import com.ahm.capacitor.camera.preview.model.CameraSessionConfiguration;
-import com.ahm.capacitor.camera.preview.model.LensInfo;
-import com.ahm.capacitor.camera.preview.model.ZoomFactors;
+import app.capgo.capacitor.camera.preview.model.CameraSessionConfiguration;
+import app.capgo.capacitor.camera.preview.model.LensInfo;
+import app.capgo.capacitor.camera.preview.model.ZoomFactors;
 import com.google.common.util.concurrent.ListenableFuture;
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
@@ -85,7 +85,6 @@ import java.nio.ByteBuffer;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
@@ -99,6 +98,7 @@ import org.json.JSONObject;
 public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
   private static final String TAG = "CameraPreview CameraXView";
+  private static final String FOCUS_INDICATOR_TAG = "cpcp_focus_indicator";
 
   public interface CameraXViewListener {
     void onPictureTaken(String base64, JSONObject exif);
@@ -124,12 +124,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   private File currentVideoFile;
   private VideoRecordingCallback currentVideoCallback;
   private PreviewView previewView;
-  private Preview previewUseCase;
   private GridOverlayView gridOverlayView;
   private FrameLayout previewContainer;
   private View focusIndicatorView;
   private long focusIndicatorAnimationId = 0; // Incrementing token to invalidate previous animations
-  private boolean disableFocusIndicator = false; // Default to false for backward compatibility
   private CameraSelector currentCameraSelector;
   private String currentDeviceId;
   private int currentFlashMode = ImageCapture.FLASH_MODE_OFF;
@@ -144,21 +142,55 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   private Size currentPreviewResolution = null;
   private ListenableFuture<FocusMeteringResult> currentFocusFuture = null; // Track current focus operation
   private String currentExposureMode = "CONTINUOUS"; // Default behavior
-  private boolean isVideoCaptureInitializing = false;
   // Capture/stop coordination
   private final Object captureLock = new Object();
   private volatile boolean isCapturingPhoto = false;
   private volatile boolean stopRequested = false;
   private volatile boolean previewDetachedOnDeferredStop = false;
 
-  public boolean isCapturing() {
-    return isCapturingPhoto;
+  // Operation coordination (acts like a semaphore to prevent stop during active ops)
+  private final Object operationLock = new Object();
+  private int activeOperations = 0;
+  private boolean stopPending = false;
+
+  private boolean IsOperationRunning(String name) {
+    synchronized (operationLock) {
+      if (stopPending) {
+        Log.d(TAG, "beginOperation: blocked '" + name + "' due to stopPending");
+        return true;
+      }
+      activeOperations++;
+      Log.v(
+        TAG,
+        "beginOperation: '" + name + "' (active=" + activeOperations + ")"
+      );
+      return false;
+    }
   }
 
-  public boolean isStopDeferred() {
-    synchronized (captureLock) {
-      return isCapturingPhoto && stopRequested;
+  private void endOperation(String name) {
+    boolean shouldStop = false;
+    synchronized (operationLock) {
+      if (activeOperations > 0) activeOperations--;
+      Log.v(
+        TAG,
+        "endOperation: '" + name + "' (active=" + activeOperations + ")"
+      );
+      if (activeOperations == 0 && stopPending) {
+        shouldStop = true;
+      }
     }
+    if (shouldStop) {
+      Log.d(
+        TAG,
+        "endOperation: all operations complete; performing deferred stop"
+      );
+      performImmediateStop();
+    }
+  }
+
+  public boolean isCapturing() {
+    return isCapturingPhoto;
   }
 
   public boolean isBusy() {
@@ -269,9 +301,125 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     }
   }
 
+  private void saveImageToGallery(
+    byte[] data,
+    ExifInterface sourceExif,
+    Integer finalWidth,
+    Integer finalHeight
+  ) {
+    try {
+      // First, write the bytes to a file
+      String extension = ".jpg";
+      String mimeType = "image/jpeg";
+      if (data.length >= 8) {
+        if (
+          data[0] == (byte) 0x89 &&
+          data[1] == 0x50 &&
+          data[2] == 0x4E &&
+          data[3] == 0x47
+        ) {
+          extension = ".png";
+          mimeType = "image/png";
+        } else if (
+          data[0] == (byte) 0xFF &&
+          data[1] == (byte) 0xD8 &&
+          data[2] == (byte) 0xFF
+        ) {
+          extension = ".jpg";
+          mimeType = "image/jpeg";
+        } 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
+        ),
+        "IMG_" +
+        new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(
+          new java.util.Date()
+        ) +
+        extension
+      );
+
+      FileOutputStream fos = new FileOutputStream(photo);
+      fos.write(data);
+      fos.flush();
+      fos.close();
+
+      // If JPEG and we have source EXIF, copy EXIF tags into the saved file
+      if ("image/jpeg".equals(mimeType) && sourceExif != null) {
+        try {
+          ExifInterface newExif = new ExifInterface(photo.getAbsolutePath());
+          for (String[] tag : EXIF_TAGS) {
+            String value = sourceExif.getAttribute(tag[0]);
+            if (value != null) newExif.setAttribute(tag[0], value);
+          }
+          // Normalize orientation for recompressed pixels
+          newExif.setAttribute(
+            ExifInterface.TAG_ORIENTATION,
+            Integer.toString(ExifInterface.ORIENTATION_NORMAL)
+          );
+          if (
+            finalWidth != null &&
+            finalHeight != null &&
+            finalWidth > 0 &&
+            finalHeight > 0
+          ) {
+            newExif.setAttribute(
+              ExifInterface.TAG_PIXEL_X_DIMENSION,
+              String.valueOf(finalWidth)
+            );
+            newExif.setAttribute(
+              ExifInterface.TAG_PIXEL_Y_DIMENSION,
+              String.valueOf(finalHeight)
+            );
+            newExif.setAttribute(
+              ExifInterface.TAG_IMAGE_WIDTH,
+              String.valueOf(finalWidth)
+            );
+            newExif.setAttribute(
+              ExifInterface.TAG_IMAGE_LENGTH,
+              String.valueOf(finalHeight)
+            );
+          }
+          newExif.saveAttributes();
+        } catch (Exception ex) {
+          Log.w(TAG, "Failed to write EXIF to saved gallery image", ex);
+        }
+      }
+
+      // Notify the gallery of the new image
+      MediaScannerConnection.scanFile(
+        this.context,
+        new String[] { photo.getAbsolutePath() },
+        new String[] { mimeType },
+        null
+      );
+    } catch (IOException e) {
+      Log.e(TAG, "Error saving image to gallery (with exif)", e);
+    }
+  }
+
   public void startSession(CameraSessionConfiguration config) {
     this.sessionConfig = config;
     cameraExecutor = Executors.newSingleThreadExecutor();
+    synchronized (operationLock) {
+      activeOperations = 0;
+      stopPending = false;
+    }
     mainExecutor.execute(() -> {
       lifecycleRegistry.setCurrentState(Lifecycle.State.STARTED);
       setupCamera();
@@ -279,26 +427,38 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   }
 
   public void stopSession() {
-    // If a capture is in progress, defer heavy teardown until it completes.
-    synchronized (captureLock) {
-      if (isCapturingPhoto) {
-        stopRequested = true;
-        // Hide/detach the preview immediately so UI can close, but keep camera running
-        if (!previewDetachedOnDeferredStop) {
-          mainExecutor.execute(() -> {
-            try {
-              if (previewContainer != null) {
-                ViewGroup parent = (ViewGroup) previewContainer.getParent();
-                if (parent != null) {
-                  parent.removeView(previewContainer);
-                }
+    // Mark stop pending; reject new operations and wait for active ones to finish
+    synchronized (operationLock) {
+      stopPending = true;
+    }
+    stopRequested = true;
+
+    boolean hasOps;
+    synchronized (operationLock) {
+      hasOps = activeOperations > 0;
+    }
+    if (hasOps) {
+      // Detach preview so UI can close
+      if (!previewDetachedOnDeferredStop) {
+        mainExecutor.execute(() -> {
+          try {
+            if (previewContainer != null) {
+              ViewGroup parent = (ViewGroup) previewContainer.getParent();
+              if (parent != null) {
+                parent.removeView(previewContainer);
               }
-              previewDetachedOnDeferredStop = true;
-            } catch (Exception ignored) {}
-          });
-        }
-        return;
+            }
+            previewDetachedOnDeferredStop = true;
+          } catch (Exception ignored) {}
+        });
       }
+      // Cancel focus to hasten completion
+      if (currentFocusFuture != null && !currentFocusFuture.isDone()) {
+        try {
+          currentFocusFuture.cancel(true);
+        } catch (Exception ignored) {}
+      }
+      return;
     }
 
     performImmediateStop();
@@ -328,6 +488,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       } finally {
         stopRequested = false;
         previewDetachedOnDeferredStop = false;
+        synchronized (operationLock) {
+          activeOperations = 0;
+          stopPending = false;
+        }
         if (listener != null) {
           try {
             listener.onCameraStopped();
@@ -381,6 +545,11 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     // Create and setup the preview view
     previewView = new PreviewView(context);
+    // Use TextureView-backed implementation for broader device compatibility when overlaying with WebView
+    // This avoids SurfaceView z-order issues seen on some MIUI/EMUI devices.
+    previewView.setImplementationMode(
+      PreviewView.ImplementationMode.COMPATIBLE
+    );
     // Match iOS behavior: FIT when no aspect ratio, FILL when aspect ratio is set
     String initialAspectRatio = sessionConfig != null
       ? sessionConfig.getAspectRatio()
@@ -394,58 +563,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     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);
+    // Intentionally no native gesture handling (tap-to-focus, pinch-to-zoom)
+    // Focus and zoom are controlled exclusively via JS API calls for parity with iOS.
 
     previewContainer.addView(
       previewView,
@@ -578,6 +697,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     int webViewHeight = webView != null ? webView.getHeight() : 0;
 
     // Get parent dimensions
+    assert webView != null;
     ViewGroup parent = (ViewGroup) webView.getParent();
     int parentWidth = parent != null ? parent.getWidth() : 0;
     int parentHeight = parent != null ? parent.getHeight() : 0;
@@ -663,20 +783,18 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           );
 
           // For centered mode with aspect ratio, calculate maximum size that fits
-          int availableWidth = screenWidthPx;
-          int availableHeight = screenHeightPx;
 
           Log.d(
             TAG,
             "Available space for preview: " +
-            availableWidth +
+            screenWidthPx +
             "x" +
-            availableHeight
+            screenHeightPx
           );
 
           // Calculate maximum size that fits the aspect ratio in available space
-          double maxWidthByHeight = availableHeight * ratio;
-          double maxHeightByWidth = availableWidth / ratio;
+          double maxWidthByHeight = screenHeightPx * ratio;
+          double maxHeightByWidth = screenWidthPx / ratio;
 
           Log.d(
             TAG,
@@ -686,21 +804,21 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             maxHeightByWidth
           );
 
-          if (maxWidthByHeight <= availableWidth) {
+          if (maxWidthByHeight <= screenWidthPx) {
             // Height is the limiting factor
             width = (int) maxWidthByHeight;
-            height = availableHeight;
+            height = screenHeightPx;
             Log.d(TAG, "Height-limited sizing: " + width + "x" + height);
           } else {
             // Width is the limiting factor
-            width = availableWidth;
+            width = screenWidthPx;
             height = (int) maxHeightByWidth;
             Log.d(TAG, "Width-limited sizing: " + width + "x" + height);
           }
 
           // Center the preview
-          x = (availableWidth - width) / 2;
-          y = (availableHeight - height) / 2;
+          x = (screenWidthPx - width) / 2;
+          y = (screenHeightPx - height) / 2;
 
           Log.d(TAG, "Auto-centered position: x=" + x + ", y=" + y);
         } catch (NumberFormatException e) {
@@ -805,7 +923,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           .setTargetRotation(rotation)
           .build();
         // Keep reference to preview use case for later re-binding (e.g., when enabling video)
-        previewUseCase = preview;
         imageCapture = new ImageCapture.Builder()
           .setResolutionSelector(resolutionSelector)
           .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
@@ -1062,25 +1179,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     return builder.build();
   }
 
-  private static String getCameraId(
-    androidx.camera.core.CameraInfo cameraInfo
-  ) {
-    try {
-      // Generate a stable ID based on camera characteristics
-      boolean isBack = isBackCamera(cameraInfo);
-      float minZoom = Objects.requireNonNull(
-        cameraInfo.getZoomState().getValue()
-      ).getMinZoomRatio();
-      float maxZoom = cameraInfo.getZoomState().getValue().getMaxZoomRatio();
-
-      // Create a unique ID based on camera properties
-      String position = isBack ? "back" : "front";
-      return position + "_" + minZoom + "_" + maxZoom;
-    } catch (Exception e) {
-      return "unknown_camera";
-    }
-  }
-
   private static boolean isBackCamera(
     androidx.camera.core.CameraInfo cameraInfo
   ) {
@@ -1108,6 +1206,11 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     Integer height,
     Location location
   ) {
+    // Prevent capture if a stop is pending
+    if (IsOperationRunning("capturePhoto")) {
+      Log.d(TAG, "capturePhoto: Ignored because stop is pending");
+      return;
+    }
     Log.d(
       TAG,
       "capturePhoto: Starting photo capture with quality: " +
@@ -1129,9 +1232,15 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       isCapturingPhoto = true;
     }
 
-    File tempFile = new File(context.getCacheDir(), "temp_image.jpg");
+    ByteArrayOutputStream imageStream = new ByteArrayOutputStream();
+    ImageCapture.Metadata metadata = new ImageCapture.Metadata();
+    if (location != null) {
+      metadata.setLocation(location);
+    }
     ImageCapture.OutputFileOptions outputFileOptions =
-      new ImageCapture.OutputFileOptions.Builder(tempFile).build();
+      new ImageCapture.OutputFileOptions.Builder(imageStream)
+        .setMetadata(metadata)
+        .build();
 
     imageCapture.takePicture(
       outputFileOptions,
@@ -1152,6 +1261,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
               performImmediateStop();
             }
           }
+          endOperation("capturePhoto");
         }
 
         @Override
@@ -1159,20 +1269,14 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
           @NonNull ImageCapture.OutputFileResults output
         ) {
           try {
-            // 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();
+            byte[] bytes = imageStream.toByteArray();
+            int finalWidthOut = -1;
+            int finalHeightOut = -1;
 
             ExifInterface exifInterface = new ExifInterface(
-              tempFile.getAbsolutePath()
+              new ByteArrayInputStream(bytes)
             );
-
-            if (location != null) {
-              exifInterface.setGpsInfo(location);
-            }
-
+            // Build EXIF JSON from captured bytes (location applied by metadata if provided)
             JSONObject exifData = getExifData(exifInterface);
 
             if (width != null || height != null) {
@@ -1181,6 +1285,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 0,
                 bytes.length
               );
+              bitmap = applyExifOrientation(bitmap, exifInterface);
               Bitmap resizedBitmap = resizeBitmapToMaxDimensions(
                 bitmap,
                 width,
@@ -1194,8 +1299,19 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
               );
               bytes = stream.toByteArray();
 
-              // Write EXIF data back to resized image
-              bytes = writeExifToImageBytes(bytes, exifInterface);
+              // Update EXIF JSON to reflect new dimensions; no in-place EXIF write to bytes
+              try {
+                exifData.put("PixelXDimension", resizedBitmap.getWidth());
+                exifData.put("PixelYDimension", resizedBitmap.getHeight());
+                exifData.put("ImageWidth", resizedBitmap.getWidth());
+                exifData.put("ImageLength", resizedBitmap.getHeight());
+                exifData.put(
+                  "Orientation",
+                  Integer.toString(ExifInterface.ORIENTATION_NORMAL)
+                );
+              } catch (Exception ignore) {}
+              finalWidthOut = resizedBitmap.getWidth();
+              finalHeightOut = resizedBitmap.getHeight();
             } else {
               // No explicit size/ratio: crop to match current preview content
               Bitmap originalBitmap = BitmapFactory.decodeByteArray(
@@ -1203,6 +1319,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 0,
                 bytes.length
               );
+              originalBitmap = applyExifOrientation(
+                originalBitmap,
+                exifInterface
+              );
               Bitmap previewCropped = cropBitmapToMatchPreview(originalBitmap);
               ByteArrayOutputStream stream = new ByteArrayOutputStream();
               previewCropped.compress(
@@ -1211,16 +1331,30 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 stream
               );
               bytes = stream.toByteArray();
-              // Preserve EXIF
-              bytes = writeExifToImageBytes(bytes, exifInterface);
+              // Update EXIF JSON to reflect cropped dimensions; no in-place EXIF write to bytes
+              try {
+                exifData.put("PixelXDimension", previewCropped.getWidth());
+                exifData.put("PixelYDimension", previewCropped.getHeight());
+                exifData.put("ImageWidth", previewCropped.getWidth());
+                exifData.put("ImageLength", previewCropped.getHeight());
+                exifData.put(
+                  "Orientation",
+                  Integer.toString(ExifInterface.ORIENTATION_NORMAL)
+                );
+              } catch (Exception ignore) {}
+              finalWidthOut = previewCropped.getWidth();
+              finalHeightOut = previewCropped.getHeight();
             }
 
-            // Save to gallery asynchronously if requested
+            // Save to gallery asynchronously if requested, copy EXIF to file
             if (saveToGallery) {
               final byte[] finalBytes = bytes;
-              new Thread(() -> {
-                saveImageToGallery(finalBytes);
-              }).start();
+              final ExifInterface exifForFile = exifInterface;
+              final Integer fW = (finalWidthOut > 0) ? finalWidthOut : null;
+              final Integer fH = (finalHeightOut > 0) ? finalHeightOut : null;
+              new Thread(() ->
+                saveImageToGallery(finalBytes, exifForFile, fW, fH)
+              ).start();
             }
 
             String resultValue;
@@ -1241,6 +1375,42 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 outFos.write(bytes);
                 outFos.close();
 
+                // Write EXIF into the saved file
+                try {
+                  ExifInterface newExif = new ExifInterface(
+                    outFile.getAbsolutePath()
+                  );
+                  for (String[] tag : EXIF_TAGS) {
+                    String value = exifInterface.getAttribute(tag[0]);
+                    if (value != null) newExif.setAttribute(tag[0], value);
+                  }
+                  newExif.setAttribute(
+                    ExifInterface.TAG_ORIENTATION,
+                    Integer.toString(ExifInterface.ORIENTATION_NORMAL)
+                  );
+                  if (finalWidthOut > 0 && finalHeightOut > 0) {
+                    newExif.setAttribute(
+                      ExifInterface.TAG_PIXEL_X_DIMENSION,
+                      String.valueOf(finalWidthOut)
+                    );
+                    newExif.setAttribute(
+                      ExifInterface.TAG_PIXEL_Y_DIMENSION,
+                      String.valueOf(finalHeightOut)
+                    );
+                    newExif.setAttribute(
+                      ExifInterface.TAG_IMAGE_WIDTH,
+                      String.valueOf(finalWidthOut)
+                    );
+                    newExif.setAttribute(
+                      ExifInterface.TAG_IMAGE_LENGTH,
+                      String.valueOf(finalHeightOut)
+                    );
+                  }
+                  newExif.saveAttributes();
+                } catch (Exception ex) {
+                  Log.w(TAG, "Failed to embed EXIF into output file", ex);
+                }
+
                 // Return a file path; apps can convert via Capacitor.convertFileSrc on JS side
                 resultValue = outFile.getAbsolutePath();
               } catch (IOException ioEx) {
@@ -1253,8 +1423,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
               resultValue = Base64.encodeToString(bytes, Base64.NO_WRAP);
             }
 
-            tempFile.delete();
-
             if (listener != null) {
               listener.onPictureTaken(resultValue, exifData);
             }
@@ -1273,14 +1441,56 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 performImmediateStop();
               }
             }
+            endOperation("capturePhoto");
           }
         }
       }
     );
   }
 
-  private Bitmap resizeBitmap(Bitmap bitmap, int width, int height) {
-    return Bitmap.createScaledBitmap(bitmap, width, height, true);
+  private int exifToDegrees(int exifOrientation) {
+    switch (exifOrientation) {
+      case ExifInterface.ORIENTATION_ROTATE_90:
+      case ExifInterface.ORIENTATION_TRANSPOSE:
+        return 90;
+      case ExifInterface.ORIENTATION_ROTATE_180:
+        return 180;
+      case ExifInterface.ORIENTATION_ROTATE_270:
+      case ExifInterface.ORIENTATION_TRANSVERSE:
+        return 270;
+      default:
+        return 0;
+    }
+  }
+
+  private Bitmap applyExifOrientation(Bitmap bitmap, ExifInterface exif) {
+    try {
+      int orientation = exif.getAttributeInt(
+        ExifInterface.TAG_ORIENTATION,
+        ExifInterface.ORIENTATION_UNDEFINED
+      );
+      int rotation = exifToDegrees(orientation);
+      if (rotation == 0) return bitmap;
+      Matrix m = new Matrix();
+      m.postRotate(rotation);
+      Bitmap rotated = Bitmap.createBitmap(
+        bitmap,
+        0,
+        0,
+        bitmap.getWidth(),
+        bitmap.getHeight(),
+        m,
+        true
+      );
+      if (rotated != bitmap) {
+        try {
+          bitmap.recycle();
+        } catch (Exception ignore) {}
+      }
+      return rotated;
+    } catch (Exception e) {
+      return bitmap;
+    }
   }
 
   private Bitmap resizeBitmapToMaxDimensions(
@@ -1292,7 +1502,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     int originalHeight = bitmap.getHeight();
     float originalAspectRatio = (float) originalWidth / originalHeight;
 
-    int targetWidth = originalWidth;
+    int targetWidth;
     int targetHeight = originalHeight;
 
     if (maxWidth != null && maxHeight != null) {
@@ -1501,54 +1711,14 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     { 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
-    }
-  }
+  // Note: We avoid temporary files for EXIF writes. When we transform pixels (resize/crop),
+  // we recompress JPEG in-memory and update EXIF info only in the returned JSON, not in the bytes.
 
   public void captureSample(int quality) {
+    if (IsOperationRunning("captureSample")) {
+      Log.d(TAG, "captureSample: Ignored because stop is pending");
+      return;
+    }
     Log.d(
       TAG,
       "captureSample: Starting sample capture with quality: " + quality
@@ -1572,10 +1742,12 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
               "Sample capture failed: " + exception.getMessage()
             );
           }
+          endOperation("captureSample");
         }
 
         @Override
         public void onCaptureSuccess(@NonNull ImageProxy image) {
+          //noinspection TryFinallyCanBeTryWithResources
           try {
             // Convert ImageProxy to byte array
             byte[] bytes = imageProxyToByteArray(image);
@@ -1593,6 +1765,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             }
           } finally {
             image.close();
+            endOperation("captureSample");
           }
         }
       }
@@ -1653,13 +1826,13 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   // not workin for xiaomi https://xiaomi.eu/community/threads/mi-11-ultra-unable-to-access-camera-lenses-in-apps-camera2-api.61456/
   @OptIn(markerClass = ExperimentalCamera2Interop.class)
   public static List<
-    com.ahm.capacitor.camera.preview.model.CameraDevice
+    app.capgo.capacitor.camera.preview.model.CameraDevice
   > getAvailableDevicesStatic(Context context) {
     Log.d(
       TAG,
       "getAvailableDevicesStatic: Starting CameraX device enumeration with getPhysicalCameraInfos."
     );
-    List<com.ahm.capacitor.camera.preview.model.CameraDevice> devices =
+    List<app.capgo.capacitor.camera.preview.model.CameraDevice> devices =
       new ArrayList<>();
     try {
       ListenableFuture<ProcessCameraProvider> cameraProviderFuture =
@@ -1683,7 +1856,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         List<LensInfo> logicalLenses = new ArrayList<>();
         logicalLenses.add(new LensInfo(4.25f, "wideAngle", 1.0f, maxZoom));
         devices.add(
-          new com.ahm.capacitor.camera.preview.model.CameraDevice(
+          new app.capgo.capacitor.camera.preview.model.CameraDevice(
             logicalCameraId,
             "Logical Camera (" + position + ")",
             position,
@@ -1782,7 +1955,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
               );
 
               devices.add(
-                new com.ahm.capacitor.camera.preview.model.CameraDevice(
+                new app.capgo.capacitor.camera.preview.model.CameraDevice(
                   physicalId,
                   label,
                   position,
@@ -1930,6 +2103,29 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   }
 
   public void setFocus(float x, float y) throws Exception {
+    // Ignore focus if capture/stop is in progress or view is gone
+    synchronized (captureLock) {
+      if (isCapturingPhoto || stopRequested) {
+        Log.d(TAG, "setFocus: Ignored because capture/stop in progress");
+        return;
+      }
+    }
+    if (
+      !isRunning ||
+      camera == null ||
+      previewView == null ||
+      previewContainer == null
+    ) {
+      Log.d(
+        TAG,
+        "setFocus: Ignored because camera/view not ready or not running"
+      );
+      return;
+    }
+    if (IsOperationRunning("setFocus")) {
+      Log.d(TAG, "setFocus: Ignored because stop is pending");
+      return;
+    }
     if (camera == null) {
       throw new Exception("Camera not initialized");
     }
@@ -1955,7 +2151,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       ExposureState state = camera.getCameraInfo().getExposureState();
       Range<Integer> range = state.getExposureCompensationRange();
       int zeroIdx = 0;
-      if (range != null && !range.contains(0)) {
+      if (!range.contains(0)) {
         // Choose the closest index to 0 if 0 is not available
         zeroIdx = Math.abs(range.getLower()) < Math.abs(range.getUpper())
           ? range.getLower()
@@ -1978,9 +2174,18 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     // Only show focus indicator after validation passes
     float indicatorX = x * viewWidth;
     float indicatorY = y * viewHeight;
-    showFocusIndicator(indicatorX, indicatorY);
+    final long indicatorToken;
+    long indicatorToken1;
+    try {
+      indicatorToken1 = showFocusIndicator(indicatorX, indicatorY);
+    } catch (Exception ignore) {
+      // If we can't show the indicator (e.g., view is gone), still proceed with metering
+      // Use current token so hide is a no-op later
+      indicatorToken1 = focusIndicatorAnimationId;
+    }
 
     // Create MeteringPoint using the preview view
+    indicatorToken = indicatorToken1;
     MeteringPointFactory factory = previewView.getMeteringPointFactory();
     MeteringPoint point = factory.createPoint(x * viewWidth, y * viewHeight);
 
@@ -2026,6 +2231,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             if (currentFocusFuture == future && currentFocusFuture.isDone()) {
               currentFocusFuture = null;
             }
+            hideFocusIndicator(indicatorToken);
+            endOperation("setFocus");
           }
         },
         ContextCompat.getMainExecutor(context)
@@ -2033,6 +2240,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     } catch (Exception e) {
       currentFocusFuture = null;
       Log.e(TAG, "Failed to set focus: " + e.getMessage());
+      hideFocusIndicator(indicatorToken);
+      endOperation("setFocus");
       throw e;
     }
   }
@@ -2056,40 +2265,36 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     }
     String normalized = mode.toUpperCase(Locale.US);
 
-    try {
-      Camera2CameraControl c2 = Camera2CameraControl.from(
-        camera.getCameraControl()
-      );
-      switch (normalized) {
-        case "LOCK": {
-          CaptureRequestOptions opts = new CaptureRequestOptions.Builder()
-            .setCaptureRequestOption(CaptureRequest.CONTROL_AE_LOCK, true)
-            .setCaptureRequestOption(
-              CaptureRequest.CONTROL_AE_MODE,
-              CaptureRequest.CONTROL_AE_MODE_ON
-            )
-            .build();
-          mainExecutor.execute(() -> c2.setCaptureRequestOptions(opts));
-          currentExposureMode = "LOCK";
-          break;
-        }
-        case "CONTINUOUS": {
-          CaptureRequestOptions opts = new CaptureRequestOptions.Builder()
-            .setCaptureRequestOption(CaptureRequest.CONTROL_AE_LOCK, false)
-            .setCaptureRequestOption(
-              CaptureRequest.CONTROL_AE_MODE,
-              CaptureRequest.CONTROL_AE_MODE_ON
-            )
-            .build();
-          mainExecutor.execute(() -> c2.setCaptureRequestOptions(opts));
-          currentExposureMode = "CONTINUOUS";
-          break;
-        }
-        default:
-          throw new Exception("Unsupported exposure mode: " + mode);
+    Camera2CameraControl c2 = Camera2CameraControl.from(
+      camera.getCameraControl()
+    );
+    switch (normalized) {
+      case "LOCK": {
+        CaptureRequestOptions opts = new CaptureRequestOptions.Builder()
+          .setCaptureRequestOption(CaptureRequest.CONTROL_AE_LOCK, true)
+          .setCaptureRequestOption(
+            CaptureRequest.CONTROL_AE_MODE,
+            CaptureRequest.CONTROL_AE_MODE_ON
+          )
+          .build();
+        mainExecutor.execute(() -> c2.setCaptureRequestOptions(opts));
+        currentExposureMode = "LOCK";
+        break;
       }
-    } catch (Exception e) {
-      throw e;
+      case "CONTINUOUS": {
+        CaptureRequestOptions opts = new CaptureRequestOptions.Builder()
+          .setCaptureRequestOption(CaptureRequest.CONTROL_AE_LOCK, false)
+          .setCaptureRequestOption(
+            CaptureRequest.CONTROL_AE_MODE,
+            CaptureRequest.CONTROL_AE_MODE_ON
+          )
+          .build();
+        mainExecutor.execute(() -> c2.setCaptureRequestOptions(opts));
+        currentExposureMode = "CONTINUOUS";
+        break;
+      }
+      default:
+        throw new Exception("Unsupported exposure mode: " + mode);
     }
   }
 
@@ -2100,9 +2305,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     ExposureState state = camera.getCameraInfo().getExposureState();
     Range<Integer> idxRange = state.getExposureCompensationRange();
     Rational step = state.getExposureCompensationStep();
-    float evStep = step != null
-      ? (float) step.getNumerator() / (float) step.getDenominator()
-      : 1.0f;
+    float evStep = (float) step.getNumerator() / (float) step.getDenominator();
     float min = idxRange.getLower() * evStep;
     float max = idxRange.getUpper() * evStep;
     return new float[] { min, max, evStep };
@@ -2115,9 +2318,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     ExposureState state = camera.getCameraInfo().getExposureState();
     int idx = state.getExposureCompensationIndex();
     Rational step = state.getExposureCompensationStep();
-    float evStep = step != null
-      ? (float) step.getNumerator() / (float) step.getDenominator()
-      : 1.0f;
+    float evStep = (float) step.getNumerator() / (float) step.getDenominator();
     return idx * evStep;
   }
 
@@ -2128,9 +2329,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     ExposureState state = camera.getCameraInfo().getExposureState();
     Range<Integer> idxRange = state.getExposureCompensationRange();
     Rational step = state.getExposureCompensationStep();
-    float evStep = step != null
-      ? (float) step.getNumerator() / (float) step.getDenominator()
-      : 1.0f;
+    float evStep = (float) step.getNumerator() / (float) step.getDenominator();
     if (evStep <= 0f) evStep = 1.0f;
     int idx = Math.round(ev / evStep);
     // clamp
@@ -2139,13 +2338,14 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     camera.getCameraControl().setExposureCompensationIndex(idx);
   }
 
-  private void showFocusIndicator(float x, float y) {
-    if (disableFocusIndicator || sessionConfig.getDisableFocusIndicator()) {
-      return;
-    }
+  private long showFocusIndicator(float x, float y) {
+    // If preview is gone (e.g., stopping/closing), bail out safely
     if (previewContainer == null) {
       Log.w(TAG, "showFocusIndicator: previewContainer is null");
-      return;
+      return focusIndicatorAnimationId;
+    }
+    if (sessionConfig.getDisableFocusIndicator()) {
+      return focusIndicatorAnimationId;
     }
 
     // Check if container has been laid out
@@ -2155,17 +2355,24 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         "showFocusIndicator: previewContainer not laid out yet, posting to run after layout"
       );
       previewContainer.post(() -> showFocusIndicator(x, y));
-      return;
+      return focusIndicatorAnimationId;
     }
 
-    // Remove any existing focus indicator and cancel its animation
-    if (focusIndicatorView != null) {
-      try {
-        focusIndicatorView.clearAnimation();
-      } catch (Exception ignore) {}
-      previewContainer.removeView(focusIndicatorView);
-      focusIndicatorView = null;
-    }
+    // Remove any existing focus indicators (ensure only one is visible)
+    try {
+      for (int i = previewContainer.getChildCount() - 1; i >= 0; i--) {
+        View child = previewContainer.getChildAt(i);
+        CharSequence desc = child.getContentDescription();
+        if (desc != null && FOCUS_INDICATOR_TAG.contentEquals(desc)) {
+          previewContainer.removeViewAt(i);
+        }
+      }
+      if (focusIndicatorView != null) {
+        ViewGroup parent = (ViewGroup) focusIndicatorView.getParent();
+        if (parent != null) parent.removeView(focusIndicatorView);
+        focusIndicatorView = null;
+      }
+    } catch (Exception ignore) {}
 
     // Create an elegant focus indicator
     FrameLayout container = new FrameLayout(context);
@@ -2178,11 +2385,11 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     params.leftMargin = Math.max(
       0,
-      Math.min((int) (x - size / 2), containerWidth - size)
+      Math.min((int) (x - (float) size / 2), containerWidth - size)
     );
     params.topMargin = Math.max(
       0,
-      Math.min((int) (y - size / 2), containerHeight - size)
+      Math.min((int) (y - (float) size / 2), containerHeight - size)
     );
 
     // iOS Camera style: square with mid-edge ticks
@@ -2197,7 +2404,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     // Add 4 tiny mid-edge ticks inside the square
     int tickLen = (int) (12 *
       context.getResources().getDisplayMetrics().density);
-    int inset = stroke; // ticks should touch the sides
+    // ticks should touch the sides
     // Top tick (perpendicular): vertical inward from top edge
     View topTick = new View(context);
     FrameLayout.LayoutParams topParams = new FrameLayout.LayoutParams(
@@ -2205,7 +2412,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       tickLen
     );
     topParams.leftMargin = (size - stroke) / 2;
-    topParams.topMargin = inset;
+    topParams.topMargin = stroke;
     topTick.setLayoutParams(topParams);
     topTick.setBackgroundColor(Color.YELLOW);
     container.addView(topTick);
@@ -2216,7 +2423,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       tickLen
     );
     bottomParams.leftMargin = (size - stroke) / 2;
-    bottomParams.topMargin = size - inset - tickLen;
+    bottomParams.topMargin = size - stroke - tickLen;
     bottomTick.setLayoutParams(bottomParams);
     bottomTick.setBackgroundColor(Color.YELLOW);
     container.addView(bottomTick);
@@ -2226,7 +2433,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       tickLen,
       stroke
     );
-    leftParams.leftMargin = inset;
+    leftParams.leftMargin = stroke;
     leftParams.topMargin = (size - stroke) / 2;
     leftTick.setLayoutParams(leftParams);
     leftTick.setBackgroundColor(Color.YELLOW);
@@ -2237,21 +2444,22 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       tickLen,
       stroke
     );
-    rightParams.leftMargin = size - inset - tickLen;
+    rightParams.leftMargin = size - stroke - tickLen;
     rightParams.topMargin = (size - stroke) / 2;
     rightTick.setLayoutParams(rightParams);
     rightTick.setBackgroundColor(Color.YELLOW);
     container.addView(rightTick);
 
+    container.setContentDescription(FOCUS_INDICATOR_TAG);
     focusIndicatorView = container;
     // Bump animation token; everything after this must validate against this token
     final long thisAnimationId = ++focusIndicatorAnimationId;
     final View thisIndicatorView = focusIndicatorView;
 
-    // Set initial state for smooth animation (mirror iOS)
-    focusIndicatorView.setAlpha(0f);
-    focusIndicatorView.setScaleX(1.5f);
-    focusIndicatorView.setScaleY(1.5f);
+    // Show immediately (avoid complex animations that can race with teardown)
+    focusIndicatorView.setAlpha(1f);
+    focusIndicatorView.setScaleX(1f);
+    focusIndicatorView.setScaleY(1f);
     focusIndicatorView.setVisibility(View.VISIBLE);
 
     // Ensure container doesn't intercept touch events
@@ -2259,12 +2467,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     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);
-    }
+    focusIndicatorView.setElevation(10f);
 
     // Add to container first
     previewContainer.addView(focusIndicatorView, params);
@@ -2275,88 +2478,43 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     // Force a layout pass to ensure the view is properly positioned
     previewContainer.requestLayout();
 
-    // First phase: fade in and scale to 1.0 over 150ms
-    focusIndicatorView
-      .animate()
-      .alpha(1f)
-      .scaleX(1f)
-      .scaleY(1f)
-      .setDuration(150)
-      .start();
-
-    // Phase 2: after 500ms, fade to 0.3 over 200ms
-    focusIndicatorView.postDelayed(
-      new Runnable() {
-        @Override
-        public void run() {
-          // Ensure this runnable belongs to the latest indicator
+    // Do not schedule delayed cleanup; indicator will be removed when focus completes
+    return thisAnimationId;
+  }
+
+  private void hideFocusIndicator(long token) {
+    // If we're stopping or not running anymore, don't attempt to touch the view tree
+    if (stopRequested || !isRunning) {
+      focusIndicatorView = null;
+      return;
+    }
+    try {
+      mainExecutor.execute(() -> {
+        try {
           if (
-            focusIndicatorView != null &&
-            thisIndicatorView == focusIndicatorView &&
-            thisAnimationId == focusIndicatorAnimationId
+            focusIndicatorView == null ||
+            previewContainer == null ||
+            token != focusIndicatorAnimationId
           ) {
-            focusIndicatorView
-              .animate()
-              .alpha(0.3f)
-              .setDuration(200)
-              .withEndAction(
-                new Runnable() {
-                  @Override
-                  public void run() {
-                    // Phase 3: after 200ms more, fade out to 0 and scale to 0.8 over 300ms
-                    focusIndicatorView.postDelayed(
-                      new Runnable() {
-                        @Override
-                        public void run() {
-                          if (
-                            focusIndicatorView != null &&
-                            thisIndicatorView == focusIndicatorView &&
-                            thisAnimationId == focusIndicatorAnimationId
-                          ) {
-                            focusIndicatorView
-                              .animate()
-                              .alpha(0f)
-                              .scaleX(0.8f)
-                              .scaleY(0.8f)
-                              .setDuration(300)
-                              .setInterpolator(
-                                new android.view.animation.AccelerateInterpolator()
-                              )
-                              .withEndAction(
-                                new Runnable() {
-                                  @Override
-                                  public void run() {
-                                    if (
-                                      focusIndicatorView != null &&
-                                      previewContainer != null &&
-                                      thisIndicatorView == focusIndicatorView &&
-                                      thisAnimationId ==
-                                      focusIndicatorAnimationId
-                                    ) {
-                                      try {
-                                        focusIndicatorView.clearAnimation();
-                                      } catch (Exception ignore) {}
-                                      previewContainer.removeView(
-                                        focusIndicatorView
-                                      );
-                                      focusIndicatorView = null;
-                                    }
-                                  }
-                                }
-                              );
-                          }
-                        }
-                      },
-                      200
-                    );
-                  }
-                }
-              );
+            return;
           }
+          // If the view hierarchy is already being torn down, skip safely
+          if (!previewContainer.isAttachedToWindow()) {
+            focusIndicatorView = null;
+            return;
+          }
+          ViewGroup parent = (ViewGroup) focusIndicatorView.getParent();
+          if (parent != null) {
+            parent.removeView(focusIndicatorView);
+          }
+        } catch (Exception ignore) {} finally {
+          focusIndicatorView = null;
         }
-      },
-      500
-    );
+      });
+    } catch (Exception ignore) {
+      // Executor or Looper not available; just null out the reference
+      focusIndicatorView = null;
+    }
   }
 
   public static List<Size> getSupportedPictureSizes(String facing) {
@@ -2562,7 +2720,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       sessionConfig.isToBack(), // toBack
       sessionConfig.isStoreToFile(), // storeToFile
       sessionConfig.isEnableOpacity(), // enableOpacity
-      sessionConfig.isEnableZoom(), // enableZoom
       sessionConfig.isDisableExifHeaderStripping(), // disableExifHeaderStripping
       sessionConfig.isDisableAudio(), // disableAudio
       sessionConfig.getZoomFactor(), // zoomFactor
@@ -2722,7 +2879,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       sessionConfig.getToBack(),
       sessionConfig.getStoreToFile(),
       sessionConfig.getEnableOpacity(),
-      sessionConfig.getEnableZoom(),
       sessionConfig.getDisableExifHeaderStripping(),
       sessionConfig.getDisableAudio(),
       sessionConfig.getZoomFactor(),
@@ -2737,7 +2893,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     if (isRunning && previewContainer != null) {
       mainExecutor.execute(() -> {
         // First update the UI layout - always pass null for x,y to force auto-centering (matching iOS)
-        updatePreviewLayoutForAspectRatio(aspectRatio, null, null);
+        updatePreviewLayoutForAspectRatio(aspectRatio);
 
         // Then rebind the camera with new aspect ratio configuration
         Log.d(
@@ -2826,7 +2982,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       sessionConfig.getToBack(),
       sessionConfig.getStoreToFile(),
       sessionConfig.getEnableOpacity(),
-      sessionConfig.getEnableZoom(),
       sessionConfig.getDisableExifHeaderStripping(),
       sessionConfig.getDisableAudio(),
       sessionConfig.getZoomFactor(),
@@ -2841,7 +2996,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     if (isRunning && previewContainer != null) {
       mainExecutor.execute(() -> {
         // First update the UI layout - always pass null for x,y to force auto-centering (matching iOS)
-        updatePreviewLayoutForAspectRatio(aspectRatio, null, null);
+        updatePreviewLayoutForAspectRatio(aspectRatio);
 
         // Then rebind the camera with new aspect ratio configuration
         Log.d(
@@ -2902,7 +3057,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         sessionConfig.getToBack(),
         sessionConfig.getStoreToFile(),
         sessionConfig.getEnableOpacity(),
-        sessionConfig.getEnableZoom(),
         sessionConfig.getDisableExifHeaderStripping(),
         sessionConfig.getDisableAudio(),
         sessionConfig.getZoomFactor(),
@@ -3010,6 +3164,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     // Swap dimensions if in portrait mode to match how PreviewView displays it
     if (isPortrait) {
       int temp = cameraWidth;
+      //noinspection SuspiciousNameCombination,ReassignedVariable
       cameraWidth = cameraHeight;
       cameraHeight = temp;
     }
@@ -3286,7 +3441,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             sessionConfig.getToBack(),
             sessionConfig.getStoreToFile(),
             sessionConfig.getEnableOpacity(),
-            sessionConfig.getEnableZoom(),
             sessionConfig.getDisableExifHeaderStripping(),
             sessionConfig.getDisableAudio(),
             sessionConfig.getZoomFactor(),
@@ -3318,7 +3472,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 previewContainer.post(callback);
               });
             } else {
-              previewContainer.post(() -> updateGridOverlayBounds());
+              previewContainer.post(this::updateGridOverlayBounds);
             }
           } else {
             // No camera rebinding needed, wait for layout to complete then call callback
@@ -3359,29 +3513,13 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   }
 
   private void updatePreviewLayoutForAspectRatio(String aspectRatio) {
-    updatePreviewLayoutForAspectRatio(aspectRatio, null, null);
-  }
-
-  private void updatePreviewLayoutForAspectRatio(
-    String aspectRatio,
-    Float x,
-    Float y
-  ) {
     if (previewContainer == null || aspectRatio == null) return;
 
     Log.d(
       TAG,
       "======================== UPDATE PREVIEW LAYOUT FOR ASPECT RATIO ========================"
     );
-    Log.d(
-      TAG,
-      "Input parameters - aspectRatio: " +
-      aspectRatio +
-      ", x: " +
-      x +
-      ", y: " +
-      y
-    );
+    Log.d(TAG, "Input parameters - aspectRatio: " + aspectRatio);
 
     // Get comprehensive display information
     WindowManager windowManager = (WindowManager) this.context.getSystemService(
@@ -3491,115 +3629,57 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       );
 
       // Get available space from webview dimensions
-      int availableWidth = webViewWidth;
-      int availableHeight = webViewHeight;
 
       Log.d(
         TAG,
-        "Available space from WebView: " +
-        availableWidth +
-        "x" +
-        availableHeight
+        "Available space from WebView: " + webViewWidth + "x" + webViewHeight
       );
 
       // Calculate position and size
       int finalX, finalY, finalWidth, finalHeight;
+      // Auto-center mode - match iOS behavior exactly
+      Log.d(TAG, "Auto-center mode");
 
-      if (x != null && y != null) {
-        // Manual positioning mode
-        int webViewTopInset = getWebViewTopInset();
-        int webViewLeftInset = getWebViewLeftInset();
-
-        Log.d(
-          TAG,
-          "Manual positioning mode - WebView insets: left=" +
-          webViewLeftInset +
-          ", top=" +
-          webViewTopInset
-        );
-
-        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 maximum size that fits the aspect ratio in available space
+      double maxWidthByHeight = webViewHeight * ratio;
+      double maxHeightByWidth = webViewWidth / ratio;
 
-        Log.d(
-          TAG,
-          "Max available space from position: " + maxWidth + "x" + maxHeight
-        );
-
-        // 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);
-          Log.d(TAG, "Height-constrained sizing");
-        } else {
-          Log.d(TAG, "Width-constrained sizing");
-        }
+      Log.d(
+        TAG,
+        "Aspect ratio calculations - maxWidthByHeight: " +
+        maxWidthByHeight +
+        ", maxHeightByWidth: " +
+        maxHeightByWidth
+      );
 
-        // Ensure final position stays within bounds
-        finalX = Math.max(0, Math.min(finalX, availableWidth - finalWidth));
-        finalY = Math.max(0, Math.min(finalY, availableHeight - finalHeight));
+      if (maxWidthByHeight <= webViewWidth) {
+        // Height is the limiting factor
+        finalWidth = (int) maxWidthByHeight;
+        finalHeight = webViewHeight;
+        Log.d(TAG, "Height-limited sizing: " + finalWidth + "x" + finalHeight);
       } else {
-        // Auto-center mode - match iOS behavior exactly
-        Log.d(TAG, "Auto-center mode");
-
-        // Calculate maximum size that fits the aspect ratio in available space
-        double maxWidthByHeight = availableHeight * ratio;
-        double maxHeightByWidth = availableWidth / ratio;
-
-        Log.d(
-          TAG,
-          "Aspect ratio calculations - maxWidthByHeight: " +
-          maxWidthByHeight +
-          ", maxHeightByWidth: " +
-          maxHeightByWidth
-        );
-
-        if (maxWidthByHeight <= availableWidth) {
-          // Height is the limiting factor
-          finalWidth = (int) maxWidthByHeight;
-          finalHeight = availableHeight;
-          Log.d(
-            TAG,
-            "Height-limited sizing: " + finalWidth + "x" + finalHeight
-          );
-        } else {
-          // Width is the limiting factor
-          finalWidth = availableWidth;
-          finalHeight = (int) maxHeightByWidth;
-          Log.d(TAG, "Width-limited sizing: " + finalWidth + "x" + finalHeight);
-        }
+        // Width is the limiting factor
+        finalWidth = webViewWidth;
+        finalHeight = (int) maxHeightByWidth;
+        Log.d(TAG, "Width-limited sizing: " + finalWidth + "x" + finalHeight);
+      }
 
-        // Center the preview
-        finalX = (availableWidth - finalWidth) / 2;
-        finalY = (availableHeight - finalHeight) / 2;
+      // Center the preview
+      finalX = (webViewWidth - finalWidth) / 2;
+      finalY = (webViewHeight - finalHeight) / 2;
 
-        Log.d(
-          TAG,
-          "Auto-center mode: calculated size " +
-          finalWidth +
-          "x" +
-          finalHeight +
-          " at position (" +
-          finalX +
-          ", " +
-          finalY +
-          ")"
-        );
-      }
+      Log.d(
+        TAG,
+        "Auto-center mode: calculated size " +
+        finalWidth +
+        "x" +
+        finalHeight +
+        " at position (" +
+        finalX +
+        ", " +
+        finalY +
+        ")"
+      );
 
       Log.d(
         TAG,
@@ -3627,24 +3707,22 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
       );
 
       // Compare with expected ratio based on orientation
-      if (aspectRatio != null) {
-        String[] parts = aspectRatio.split(":");
-        if (parts.length == 2) {
-          double expectedDisplayRatio = isPortrait
-            ? (ratioHeight / ratioWidth)
-            : (ratioWidth / ratioHeight);
-          double difference = Math.abs(displayedRatio - expectedDisplayRatio);
-          Log.d(
-            TAG,
-            "Display ratio check - Expected: " +
-            expectedDisplayRatio +
-            ", Actual: " +
-            displayedRatio +
-            ", Difference: " +
-            difference +
-            " (tolerance should be < 0.01)"
-          );
-        }
+      String[] parts = aspectRatio.split(":");
+      if (parts.length == 2) {
+        double expectedDisplayRatio = isPortrait
+          ? (ratioHeight / ratioWidth)
+          : (ratioWidth / ratioHeight);
+        double difference = Math.abs(displayedRatio - expectedDisplayRatio);
+        Log.d(
+          TAG,
+          "Display ratio check - Expected: " +
+          expectedDisplayRatio +
+          ", Actual: " +
+          displayedRatio +
+          ", Difference: " +
+          difference +
+          " (tolerance should be < 0.01)"
+        );
       }
 
       // Update layout params
@@ -3796,93 +3874,12 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
       Log.d(
         TAG,
-        "updateGridOverlayBounds: Updated grid bounds to " +
-        cameraBounds.toString()
+        "updateGridOverlayBounds: Updated grid bounds to " + cameraBounds
       );
     }
   }
 
-  private void triggerAutoFocus() {
-    if (camera == null) {
-      return;
-    }
-
-    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 (persistent, no auto-cancel) to match iOS behavior
-    FocusMeteringAction action = new FocusMeteringAction.Builder(
-      point,
-      FocusMeteringAction.FLAG_AF | FocusMeteringAction.FLAG_AE
-    )
-      .disableAutoCancel()
-      .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);
-    }
-  }
-
+  /** @noinspection ResultOfMethodCallIgnored*/
   public void startRecordVideo() throws Exception {
     if (videoCapture == null) {
       throw new Exception("VideoCapture is not initialized");
@@ -3921,6 +3918,15 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     // Start recording
     if (sessionConfig != null && !sessionConfig.isDisableAudio()) {
+      if (
+        ActivityCompat.checkSelfPermission(
+          context,
+          Manifest.permission.RECORD_AUDIO
+        ) !=
+        PackageManager.PERMISSION_GRANTED
+      ) {
+        return;
+      }
       currentRecording = videoCapture
         .getOutput()
         .prepareRecording(context, outputOptions)
@@ -3945,60 +3951,6 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     );
   }
 
-  private void initializeVideoCapture() throws Exception {
-    if (isVideoCaptureInitializing) {
-      throw new Exception("VideoCapture initialization is already in progress");
-    }
-    if (cameraProvider == null || camera == null) {
-      throw new Exception("Camera is not initialized");
-    }
-
-    isVideoCaptureInitializing = true;
-
-    try {
-      // Get current rotation for video capture
-      int rotation = previewView != null && previewView.getDisplay() != null
-        ? previewView.getDisplay().getRotation()
-        : android.view.Surface.ROTATION_0;
-
-      // Setup VideoCapture with rotation and quality fallback
-      QualitySelector qualitySelector = QualitySelector.fromOrderedList(
-        Arrays.asList(Quality.FHD, Quality.HD, Quality.SD),
-        FallbackStrategy.higherQualityOrLowerThan(Quality.FHD)
-      );
-      Recorder recorder = new Recorder.Builder()
-        .setQualitySelector(qualitySelector)
-        .build();
-      videoCapture = VideoCapture.withOutput(recorder);
-
-      // Reuse the Preview use case we created during initial binding
-      Preview preview = previewUseCase;
-
-      // Rebind with video capture included
-      cameraProvider.unbindAll();
-      if (preview != null) {
-        // CRITICAL: Re-set the surface provider after unbinding
-        // Without this, the preview won't be connected to the surface and video won't be captured
-        preview.setSurfaceProvider(previewView.getSurfaceProvider());
-
-        camera = cameraProvider.bindToLifecycle(
-          this,
-          currentCameraSelector,
-          preview,
-          imageCapture,
-          videoCapture
-        );
-      } else {
-        // Shouldn't happen, but handle gracefully
-        throw new Exception("Preview use case not found");
-      }
-
-      Log.d(TAG, "VideoCapture initialized successfully");
-    } finally {
-      isVideoCaptureInitializing = false;
-    }
-  }
-
   public void stopRecordVideo(VideoRecordingCallback callback) {
     if (currentRecording == null) {
       callback.onError("No video recording in progress");