@capgo/camera-preview 8.0.9 → 8.0.11

package/README.md

@@ -1317,3 +1317,14 @@ Reusable exposure mode type for cross-platform support.
 | **`TRIPLE`**     | <code>'triple'</code>    |
 
 </docgen-api>
+
+## Compatibility
+
+| Plugin version | Capacitor compatibility | Maintained |
+| -------------- | ----------------------- | ---------- |
+| v8.\*.\*       | v8.\*.\*                | ✅          |
+| v7.\*.\*       | v7.\*.\*                | On demand   |
+| v6.\*.\*       | v6.\*.\*                | ❌          |
+| v5.\*.\*       | v5.\*.\*                | ❌          |
+
+> **Note:** The major version of this plugin follows the major version of Capacitor. Use the version that matches your Capacitor installation (e.g., plugin v8 for Capacitor 8). Only the latest major version is actively maintained.

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java

@@ -936,7 +936,9 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
                         if (originalWindowBackground == null) {
                             originalWindowBackground = getBridge().getActivity().getWindow().getDecorView().getBackground();
                         }
-                        getBridge().getActivity().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
+                        // Set to solid black first to prevent flickering during transition
+                        // This provides a stable base before camera preview is ready
+                        getBridge().getActivity().getWindow().setBackgroundDrawable(new ColorDrawable(Color.BLACK));
                     } catch (Exception ignored) {}
                 }
                 DisplayMetrics metrics = getBridge().getActivity().getResources().getDisplayMetrics();
@@ -1492,6 +1494,16 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         return ret;
     }
 
+    private boolean isToBackMode() {
+        if (cameraXView != null) {
+            CameraSessionConfiguration config = cameraXView.getSessionConfig();
+            if (config != null) {
+                return config.isToBack();
+            }
+        }
+        return false;
+    }
+
     @Override
     public void onCameraStarted(int width, int height, int x, int y) {
         PluginCall call = bridge.getSavedCall(cameraStartCallbackId);
@@ -1624,6 +1636,20 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
                     ")"
             );
 
+            // Transition window background to transparent now that camera is ready
+            // This prevents flickering during camera initialization
+            if (isToBackMode()) {
+                getBridge()
+                    .getActivity()
+                    .runOnUiThread(() -> {
+                        try {
+                            getBridge().getActivity().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
+                        } catch (Exception e) {
+                            Log.w(TAG, "Failed to set window background to transparent", e);
+                        }
+                    });
+            }
+
             call.resolve(result);
             bridge.releaseCall(call);
             cameraStartCallbackId = null; // Prevent re-use
@@ -1664,6 +1690,25 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
             bridge.releaseCall(call);
             cameraStartCallbackId = null;
         }
+
+        // Restore original window background on error to prevent black screen
+        // Use synchronized block to ensure only one thread captures and clears the background.
+        // Even if multiple errors occur, only the first will have a non-null background to restore.
+        synchronized (this) {
+            final Drawable backgroundToRestore = originalWindowBackground;
+            if (backgroundToRestore != null) {
+                originalWindowBackground = null; // Clear immediately so other threads won't restore
+                getBridge()
+                    .getActivity()
+                    .runOnUiThread(() -> {
+                        try {
+                            getBridge().getActivity().getWindow().setBackgroundDrawable(backgroundToRestore);
+                        } catch (Exception e) {
+                            Log.w(TAG, "Failed to restore window background on error", e);
+                        }
+                    });
+            }
+        }
     }
 
     @PluginMethod

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java

@@ -13,6 +13,10 @@ import android.graphics.Paint;
 import android.graphics.Rect;
 import android.graphics.Typeface;
 import android.graphics.drawable.GradientDrawable;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
 import android.hardware.camera2.CameraAccessException;
 import android.hardware.camera2.CameraCharacteristics;
 import android.hardware.camera2.CameraManager;
@@ -139,6 +143,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private CameraXViewListener listener;
     private final Context context;
     private final WebView webView;
+    // WebView's default background is white; we store this to restore on error or cleanup
+    // Note: WebView doesn't provide a way to query its current background color, so we assume
+    // the default white background. This is consistent across Android versions.
+    private int originalWebViewBackground = android.graphics.Color.WHITE;
     private final LifecycleRegistry lifecycleRegistry;
     private final Executor mainExecutor;
     private ExecutorService cameraExecutor;
@@ -157,6 +165,31 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private int activeOperations = 0;
     private boolean stopPending = false;
 
+    // Sensor Fields
+    private SensorManager sensorManager;
+    private Sensor accelerometer;
+    private final float[] lastAccelerometerValues = new float[3]; // x,y, and z
+    private final Object accelerometerLock = new Object();
+    private volatile int lastCaptureRotation = -1; // -1 unknown
+
+    private final SensorEventListener accelerometerListener = new SensorEventListener() {
+        @Override
+        public void onSensorChanged(SensorEvent event) {
+            if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+                synchronized (accelerometerLock) {
+                    lastAccelerometerValues[0] = event.values[0];
+                    lastAccelerometerValues[1] = event.values[1];
+                    lastAccelerometerValues[2] = event.values[2];
+                }
+            }
+        }
+
+        @Override
+        public void onAccuracyChanged(Sensor sensor, int accuracy) {
+            // Not Needed
+        }
+    };
+
     private boolean IsOperationRunning(String name) {
         synchronized (operationLock) {
             if (stopPending) {
@@ -336,6 +369,23 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     public void startSession(CameraSessionConfiguration config) {
         this.sessionConfig = config;
         cameraExecutor = Executors.newSingleThreadExecutor();
+
+        // Reset cached orientation so we don't reuse stale values across sessions
+        synchronized (accelerometerLock) {
+            lastAccelerometerValues[0] = 0f;
+            lastAccelerometerValues[1] = 0f;
+            lastAccelerometerValues[2] = 0f;
+        }
+        lastCaptureRotation = -1;
+
+        // Start accelerometer for orientation detection regardless of lock
+        if (sensorManager == null) {
+            sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+            accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+        }
+        if (accelerometer != null) {
+            sensorManager.registerListener(accelerometerListener, accelerometer, SensorManager.SENSOR_DELAY_UI);
+        }
         synchronized (operationLock) {
             activeOperations = 0;
             stopPending = false;
@@ -386,6 +436,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     private void performImmediateStop() {
         isRunning = false;
+        // Stop accelerometer
+        if (sensorManager != null && accelerometer != null) {
+            sensorManager.unregisterListener(accelerometerListener);
+        }
         // Cancel any ongoing focus operation when stopping session
         if (currentFocusFuture != null && !currentFocusFuture.isDone()) {
             currentFocusFuture.cancel(true);
@@ -421,6 +475,22 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         });
     }
 
+    private void restoreWebViewBackground() {
+        // Capture sessionConfig reference once to avoid race conditions
+        CameraSessionConfiguration config = sessionConfig;
+        boolean shouldRestore = config != null && config.isToBack();
+        if (shouldRestore) {
+            // Capture background color before posting to UI thread
+            final int backgroundColorToRestore = originalWebViewBackground;
+            webView.post(() -> {
+                // Additional safety check in case webView context changed
+                if (webView != null) {
+                    webView.setBackgroundColor(backgroundColorToRestore);
+                }
+            });
+        }
+    }
+
     private void setupCamera() {
         ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(context);
         cameraProviderFuture.addListener(
@@ -430,6 +500,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                     setupPreviewView();
                     bindCameraUseCases();
                 } catch (Exception e) {
+                    // Restore webView background on error
+                    restoreWebViewBackground();
                     if (listener != null) {
                         listener.onCameraStartError("Error initializing camera: " + e.getMessage());
                     }
@@ -444,7 +516,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             removePreviewView();
         }
         if (sessionConfig.isToBack()) {
-            webView.setBackgroundColor(android.graphics.Color.TRANSPARENT);
+            // Set to black initially to prevent flickering, will be transparent after camera starts
+            webView.setBackgroundColor(android.graphics.Color.BLACK);
         }
 
         // Create a container to hold both the preview and grid overlay
@@ -542,6 +615,19 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
     }
 
+    /**
+     * Compute layout parameters for the camera preview container based on the current session configuration,
+     * device screen size, WebView/parent geometry, and optional aspect-ratio centering.
+     *
+     * The returned FrameLayout.LayoutParams contains width, height, leftMargin (x) and topMargin (y)
+     * for placing the preview. When an aspect ratio is specified and sessionConfig is in centered mode,
+     * the preview size is scaled to the largest area that fits the aspect ratio within the screen and
+     * any axis with a coordinate equal to -1 is auto-centered for that axis; axes explicitly provided
+     * in sessionConfig are preserved. Coordinates supplied by sessionConfig are assumed to already
+     * include WebView insets.
+     *
+     * @return a FrameLayout.LayoutParams configured with the computed preview width, height, leftMargin and topMargin
+     */
     private FrameLayout.LayoutParams calculatePreviewLayoutParams() {
         // sessionConfig already contains pixel-converted coordinates with webview offsets applied
         int x = sessionConfig.getX();
@@ -663,9 +749,13 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                         Log.d(TAG, "Width-limited sizing: " + width + "x" + height);
                     }
 
-                    // Center the preview
-                    x = (screenWidthPx - width) / 2;
-                    y = (screenHeightPx - height) / 2;
+                    // Center the preview only overwrite what was not explicitly set
+                    if (sessionConfig.getX() == -1) {
+                        x = (screenWidthPx - width) / 2;
+                    }
+                    if (sessionConfig.getY() == -1) {
+                        y = (screenHeightPx - height) / 2;
+                    }
 
                     Log.d(TAG, "Auto-centered position: x=" + x + ", y=" + y);
                 } catch (NumberFormatException e) {
@@ -714,7 +804,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         if (focusIndicatorView != null) {
             focusIndicatorView = null;
         }
-        webView.setBackgroundColor(android.graphics.Color.WHITE);
+        webView.setBackgroundColor(originalWebViewBackground);
     }
 
     @OptIn(markerClass = ExperimentalCamera2Interop.class)
@@ -784,8 +874,14 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 // Bind with or without video capture based on enableVideoMode
                 if (sessionConfig.isVideoModeEnabled() && videoCapture != null) {
                     camera = cameraProvider.bindToLifecycle(this, currentCameraSelector, preview, imageCapture, videoCapture);
+                    CameraInfo cameraInfo = camera.getCameraInfo();
+                    currentDeviceId = Camera2CameraInfo.from(cameraInfo).getCameraId();
+                    Log.d(TAG, "bindCameraUseCases: Camera successfully bound to device ID: " + currentDeviceId);
                 } else {
                     camera = cameraProvider.bindToLifecycle(this, currentCameraSelector, preview, imageCapture);
+                    CameraInfo cameraInfo = camera.getCameraInfo();
+                    currentDeviceId = Camera2CameraInfo.from(cameraInfo).getCameraId();
+                    Log.d(TAG, "bindCameraUseCases: Camera successfully bound to device ID: " + currentDeviceId);
                 }
 
                 resetExposureCompensationToDefault();
@@ -926,10 +1022,20 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                         // Update grid overlay bounds after camera is started
                         updateGridOverlayBounds();
 
+                        // Now transition to transparent background after camera is ready
+                        // This prevents flickering during camera initialization
+                        if (sessionConfig.isToBack()) {
+                            webView.post(() -> {
+                                webView.setBackgroundColor(android.graphics.Color.TRANSPARENT);
+                            });
+                        }
+
                         listener.onCameraStarted(actualWidth, actualHeight, actualX, actualY);
                     });
                 }
             } catch (Exception e) {
+                // Restore webView background on error
+                restoreWebViewBackground();
                 if (listener != null) listener.onCameraStartError("Error binding camera: " + e.getMessage());
             }
         });
@@ -971,6 +1077,50 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
     }
 
+    /**
+     * Get device rotation from accelerometer data.
+     * This works even when portrait lock is enabled.
+     * Falls back to display rotation if accelerometer data is not available.
+     */
+    private int getRotationFromAccelerometer() {
+        float x, y;
+        synchronized (accelerometerLock) {
+            x = lastAccelerometerValues[0];
+            y = lastAccelerometerValues[1];
+        }
+
+        // If no accelerometer data yet, fall back to display rotation
+        final float epsilon = 1.0f;
+        if (Math.abs(x) < epsilon && Math.abs(y) < epsilon) {
+            if (previewView != null && previewView.getDisplay() != null) {
+                return previewView.getDisplay().getRotation();
+            }
+            return android.view.Surface.ROTATION_0;
+        }
+
+        // Android accelerometer: +X is right, +Y is up, +Z is toward user
+        // Determine orientation based on which axis has the strongest gravity component
+        if (Math.abs(x) > Math.abs(y)) {
+            // Landscape orientation
+            if (x > 0) {
+                // Device tilted to the left (top of device points left)
+                return android.view.Surface.ROTATION_90;
+            } else {
+                // Device tilted to the right (top of device points right)
+                return android.view.Surface.ROTATION_270;
+            }
+        } else {
+            // Portrait orientation
+            if (y > 0) {
+                // Normal portrait (top of device points up)
+                return android.view.Surface.ROTATION_0;
+            } else {
+                // Upside down portrait
+                return android.view.Surface.ROTATION_180;
+            }
+        }
+    }
+
     public void capturePhoto(
         int quality,
         final boolean saveToGallery,
@@ -993,6 +1143,12 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             return;
         }
 
+        // Set rotation from accelerometer for device orientation regardless of lock
+        int rotation = getRotationFromAccelerometer();
+        lastCaptureRotation = rotation;
+        imageCapture.setTargetRotation(rotation);
+        Log.d(TAG, "capturePhoto: Set target rotation to " + rotation + " from accelerometer");
+
         Log.d(
             TAG,
             "capturePhoto: Starting photo capture with: " +
@@ -1744,6 +1900,19 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         Rect bounds = getActualCameraBounds();
         int previewW = Math.max(1, bounds.width());
         int previewH = Math.max(1, bounds.height());
+
+        // Check if device physical orientation differs from UI orientation
+        int rotation = (lastCaptureRotation != -1) ? lastCaptureRotation : getRotationFromAccelerometer();
+        boolean physicalInLandscape = (rotation == android.view.Surface.ROTATION_90 || rotation == android.view.Surface.ROTATION_270);
+        boolean previewIsPortrait = previewH > previewW;
+
+        // If physical orientation doesn't match preview orientation swap ratio
+        if (physicalInLandscape == previewIsPortrait) {
+            int temp = previewW;
+            previewW = previewH;
+            previewH = temp;
+        }
+
         float previewRatio = (float) previewW / (float) previewH;
 
         int imgW = image.getWidth();
@@ -1771,26 +1940,65 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     // not working 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<app.capgo.capacitor.camera.preview.model.CameraDevice> getAvailableDevicesStatic(Context context) {
-        Log.d(TAG, "getAvailableDevicesStatic: Starting CameraX device enumeration with getPhysicalCameraInfos.");
+        Log.d(TAG, "=== Starting Camera Enumeration ===");
         List<app.capgo.capacitor.camera.preview.model.CameraDevice> devices = new ArrayList<>();
         try {
             ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(context);
             ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
             CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
 
-            for (CameraInfo cameraInfo : cameraProvider.getAvailableCameraInfos()) {
+            List<CameraInfo> availableCameras = cameraProvider.getAvailableCameraInfos();
+
+            for (CameraInfo cameraInfo : availableCameras) {
                 String logicalCameraId = Camera2CameraInfo.from(cameraInfo).getCameraId();
                 String position = isBackCamera(cameraInfo) ? "rear" : "front";
 
                 // Add logical camera
-                float minZoom = Objects.requireNonNull(cameraInfo.getZoomState().getValue()).getMinZoomRatio();
-                float maxZoom = cameraInfo.getZoomState().getValue().getMaxZoomRatio();
+                ZoomState zoomState = cameraInfo.getZoomState().getValue();
+                float minZoom = zoomState != null ? zoomState.getMinZoomRatio() : 1.0f;
+                float maxZoom = zoomState != null ? zoomState.getMaxZoomRatio() : 1.0f;
+
+                // Determine device type by analyzing camera characteristics
+                String deviceType = "wideAngle";
+                float focalLength = 4.25f;
+
+                try {
+                    CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(logicalCameraId);
+                    float[] focalLengths = characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
+                    android.util.SizeF sensorSize = characteristics.get(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
+
+                    if (focalLengths != null && focalLengths.length > 0) {
+                        focalLength = focalLengths[0];
+
+                        // Calculate FOV to determine camera type
+                        if (sensorSize != null && sensorSize.getWidth() > 0) {
+                            double fov = 2 * Math.toDegrees(Math.atan(sensorSize.getWidth() / (2 * focalLength)));
+                            if (fov > 90) {
+                                deviceType = "ultraWide";
+                            } else if (fov < 40) {
+                                deviceType = "telephoto";
+                            }
+                        } else {
+                            // Fallback: classify by focal length alone
+                            if (focalLength < 3.0f) {
+                                deviceType = "ultraWide";
+                            } else if (focalLength > 5.0f) {
+                                deviceType = "telephoto";
+                            }
+                        }
+                    }
+                } catch (CameraAccessException e) {
+                    Log.e(TAG, "Failed to get characteristics for " + logicalCameraId, e);
+                }
                 List<LensInfo> logicalLenses = new ArrayList<>();
-                logicalLenses.add(new LensInfo(4.25f, "wideAngle", 1.0f, maxZoom));
+                logicalLenses.add(new LensInfo(focalLength, deviceType, 1.0f, maxZoom));
+
+                String label = "Logical " + deviceType + " (" + position + ")";
+
                 devices.add(
                     new app.capgo.capacitor.camera.preview.model.CameraDevice(
                         logicalCameraId,
-                        "Logical Camera (" + position + ")",
+                        label,
                         position,
                         logicalLenses,
                         minZoom,
@@ -1798,32 +2006,59 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                         true
                     )
                 );
-                Log.d(TAG, "Found logical camera: " + logicalCameraId + " (" + position + ") with zoom " + minZoom + "-" + maxZoom);
+                Log.d(TAG, "Added logical camera: " + logicalCameraId + " zoom: " + minZoom + "-" + maxZoom);
 
                 // Get and add physical cameras
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                     Set<CameraInfo> physicalCameraInfos = cameraInfo.getPhysicalCameraInfos();
-                    if (physicalCameraInfos.isEmpty()) continue;
+                    Log.d(TAG, "Physical camera count from CameraX: " + physicalCameraInfos.size());
 
-                    Log.d(TAG, "Logical camera " + logicalCameraId + " has " + physicalCameraInfos.size() + " physical cameras.");
+                    if (physicalCameraInfos.isEmpty()) {
+                        Log.w(TAG, "No physical cameras exposed through CameraX for " + logicalCameraId);
+
+                        // Try to get physical IDs from CameraManager
+                        try {
+                            CameraCharacteristics chars = cameraManager.getCameraCharacteristics(logicalCameraId);
+                            Set<String> physicalIds = chars.getPhysicalCameraIds();
+                            Log.d(TAG, "CameraManager reports " + physicalIds.size() + " physical cameras for " + logicalCameraId);
+                            for (String pid : physicalIds) {
+                                Log.d(TAG, "  Physical camera ID: " + pid);
+                            }
+                        } catch (CameraAccessException e) {
+                            Log.e(TAG, "Failed to get characteristics", e);
+                        }
+                        continue;
+                    }
 
                     for (CameraInfo physicalCameraInfo : physicalCameraInfos) {
                         String physicalId = Camera2CameraInfo.from(physicalCameraInfo).getCameraId();
-                        if (physicalId.equals(logicalCameraId)) continue; // Already added as logical
+                        Log.d(TAG, "Processing physical camera: " + physicalId);
+
+                        if (physicalId.equals(logicalCameraId)) {
+                            Log.d(TAG, "Skipping - same as logical ID");
+                            continue;
+                        }
 
                         try {
                             CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(physicalId);
-                            String deviceType = "wideAngle";
+                            String physicalDeviceType = "wideAngle";
                             float[] focalLengths = characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
                             android.util.SizeF sensorSize = characteristics.get(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
 
+                            Log.d(TAG, "  Focal lengths: " + (focalLengths != null ? Arrays.toString(focalLengths) : "null"));
+                            Log.d(
+                                TAG,
+                                "  Sensor size: " + (sensorSize != null ? sensorSize.getWidth() + "x" + sensorSize.getHeight() : "null")
+                            );
+
                             if (focalLengths != null && focalLengths.length > 0 && sensorSize != null && sensorSize.getWidth() > 0) {
                                 double fov = 2 * Math.toDegrees(Math.atan(sensorSize.getWidth() / (2 * focalLengths[0])));
-                                if (fov > 90) deviceType = "ultraWide";
-                                else if (fov < 40) deviceType = "telephoto";
+                                Log.d(TAG, "  Calculated FOV: " + fov);
+                                if (fov > 90) physicalDeviceType = "ultraWide";
+                                else if (fov < 40) physicalDeviceType = "telephoto";
                             } else if (focalLengths != null && focalLengths.length > 0) {
-                                if (focalLengths[0] < 3.0f) deviceType = "ultraWide";
-                                else if (focalLengths[0] > 5.0f) deviceType = "telephoto";
+                                if (focalLengths[0] < 3.0f) physicalDeviceType = "ultraWide";
+                                else if (focalLengths[0] > 5.0f) physicalDeviceType = "telephoto";
                             }
 
                             float physicalMinZoom = 1.0f;
@@ -1835,17 +2070,15 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                                     physicalMaxZoom = zoomRange.getUpper();
                                 }
                             }
-
-                            String label = "Physical " + deviceType + " (" + position + ")";
+                            float physicalFocalLength = (focalLengths != null && focalLengths.length > 0) ? focalLengths[0] : 4.25f;
+                            String physicalLabel = "Physical " + physicalDeviceType + " (" + position + ")";
                             List<LensInfo> physicalLenses = new ArrayList<>();
-                            physicalLenses.add(
-                                new LensInfo(focalLengths != null ? focalLengths[0] : 4.25f, deviceType, 1.0f, physicalMaxZoom)
-                            );
+                            physicalLenses.add(new LensInfo(physicalFocalLength, physicalDeviceType, 1.0f, physicalMaxZoom));
 
                             devices.add(
                                 new app.capgo.capacitor.camera.preview.model.CameraDevice(
                                     physicalId,
-                                    label,
+                                    physicalLabel,
                                     position,
                                     physicalLenses,
                                     physicalMinZoom,
@@ -1853,13 +2086,15 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                                     false
                                 )
                             );
-                            Log.d(TAG, "Found physical camera: " + physicalId + " (" + label + ")");
+                            Log.d(TAG, "Added physical camera: " + physicalId + " (" + physicalDeviceType + ")");
                         } catch (CameraAccessException e) {
                             Log.e(TAG, "Failed to access characteristics for physical camera " + physicalId, e);
                         }
                     }
                 }
             }
+
+            Log.d(TAG, "=== Enumeration Complete: " + devices.size() + " cameras ===");
             return devices;
         } catch (Exception e) {
             Log.e(TAG, "getAvailableDevicesStatic: Error getting devices", e);
@@ -1975,18 +2210,21 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             currentFocusFuture.cancel(true);
         }
 
-        // Reset exposure compensation to 0 on tap-to-focus
-        try {
-            ExposureState state = camera.getCameraInfo().getExposureState();
-            Range<Integer> range = state.getExposureCompensationRange();
-            int zeroIdx = 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() : range.getUpper();
+        //If locked don't auto adjust exposure
+        if (!"LOCK".equals(currentExposureMode)) {
+            // Reset exposure compensation to 0 on tap-to-focus
+            try {
+                ExposureState state = camera.getCameraInfo().getExposureState();
+                Range<Integer> range = state.getExposureCompensationRange();
+                int zeroIdx = 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() : range.getUpper();
+                }
+                camera.getCameraControl().setExposureCompensationIndex(zeroIdx);
+            } catch (Exception e) {
+                Log.w(TAG, "setFocus: Failed to reset exposure compensation to 0", e);
             }
-            camera.getCameraControl().setExposureCompensationIndex(zeroIdx);
-        } catch (Exception e) {
-            Log.w(TAG, "setFocus: Failed to reset exposure compensation to 0", e);
         }
 
         int viewWidth = previewView.getWidth();
@@ -2458,40 +2696,60 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     @OptIn(markerClass = ExperimentalCamera2Interop.class)
     public void switchToDevice(String deviceId) {
+        Log.d(TAG, "======================== SWITCH TO DEVICE ========================");
         Log.d(TAG, "switchToDevice: Attempting to switch to device " + deviceId);
 
         mainExecutor.execute(() -> {
             try {
                 // Standard physical device selection logic...
                 List<CameraInfo> cameraInfos = cameraProvider.getAvailableCameraInfos();
+
                 CameraInfo targetCameraInfo = null;
                 for (CameraInfo cameraInfo : cameraInfos) {
-                    if (deviceId.equals(Camera2CameraInfo.from(cameraInfo).getCameraId())) {
+                    String id = Camera2CameraInfo.from(cameraInfo).getCameraId();
+                    if (deviceId.equals(id)) {
                         targetCameraInfo = cameraInfo;
                         break;
                     }
                 }
 
                 if (targetCameraInfo != null) {
-                    Log.d(TAG, "switchToDevice: Found matching CameraInfo for deviceId: " + deviceId);
-                    final CameraInfo finalTarget = targetCameraInfo;
-
-                    // This filter will receive a list of all cameras and must return the one we want.
-
-                    currentCameraSelector = new CameraSelector.Builder()
-                        .addCameraFilter((cameras) -> {
-                            // This filter will receive a list of all cameras and must return the one we want.
-                            return Collections.singletonList(finalTarget);
-                        })
-                        .build();
-                    currentDeviceId = deviceId;
-                    bindCameraUseCases(); // Rebind with the new, highly specific selector
+                    // Determine position from the target camera
+                    String position = isBackCamera(targetCameraInfo) ? "rear" : "front";
+                    boolean wasCentered = sessionConfig.isCentered();
+
+                    // Update sessionConfig with the new device ID
+                    sessionConfig = new CameraSessionConfiguration(
+                        deviceId,
+                        position,
+                        sessionConfig.getX(),
+                        sessionConfig.getY(),
+                        sessionConfig.getWidth(),
+                        sessionConfig.getHeight(),
+                        sessionConfig.getPaddingBottom(),
+                        sessionConfig.getToBack(),
+                        sessionConfig.getStoreToFile(),
+                        sessionConfig.getEnableOpacity(),
+                        sessionConfig.getDisableExifHeaderStripping(),
+                        sessionConfig.getDisableAudio(),
+                        sessionConfig.getZoomFactor(),
+                        sessionConfig.getAspectRatio(),
+                        sessionConfig.getGridMode(),
+                        sessionConfig.getDisableFocusIndicator(),
+                        sessionConfig.isVideoModeEnabled()
+                    );
+
+                    sessionConfig.setCentered(wasCentered);
+
+                    Log.d(TAG, "switchToDevice: Updated sessionConfig with deviceId: " + deviceId);
+                    bindCameraUseCases(); // Will now use deviceId from sessionConfig
                 } else {
                     Log.e(TAG, "switchToDevice: Could not find any CameraInfo matching deviceId: " + deviceId);
                 }
             } catch (Exception e) {
                 Log.e(TAG, "switchToDevice: Error switching camera", e);
             }
+            Log.d(TAG, "================================================================");
         });
     }
 
@@ -3447,6 +3705,11 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             throw new Exception("Video recording is already in progress");
         }
 
+        // Update video capture rotation from accelerometer for device orientation
+        int rotation = getRotationFromAccelerometer();
+        videoCapture.setTargetRotation(rotation);
+        Log.d(TAG, "startRecordVideo: Using rotation " + rotation + " from accelerometer");
+
         // Create output file
         String fileName = "video_" + System.currentTimeMillis() + ".mp4";
         File outputDir = new File(context.getExternalFilesDir(Environment.DIRECTORY_MOVIES), "CameraPreview");

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -2,6 +2,7 @@ import AVFoundation
 import UIKit
 import CoreLocation
 import UniformTypeIdentifiers
+import CoreMotion
 
 class CameraController: NSObject {
     private func getVideoOrientation() -> AVCaptureVideoOrientation {
@@ -37,6 +38,24 @@ class CameraController: NSObject {
         return orientation
     }
 
+    // For capture only - uses accelerometer to detect physical orientation to properly position videos/images
+    private func getPhysicalOrientation() -> AVCaptureVideoOrientation {
+        guard let accelerometerData = motionManager.accelerometerData else {
+            return lastCaptureOrientation ?? getVideoOrientation() // Fallback to interface in case of accelerometer fail
+        }
+
+        let x = accelerometerData.acceleration.x
+        let y = accelerometerData.acceleration.y
+
+        if abs(x) > abs(y) {
+            // Landscape
+            return x > 0 ? .landscapeLeft : .landscapeRight
+        } else {
+            // Portrait
+            return y > 0 ? .portraitUpsideDown : .portrait
+        }
+    }
+
     var captureSession: AVCaptureSession?
     var disableFocusIndicator: Bool = false
 
@@ -74,6 +93,8 @@ class CameraController: NSObject {
     var zoomFactor: CGFloat = 1.0
     private var lastZoomUpdateTime: TimeInterval = 0
     private let zoomUpdateThrottle: TimeInterval = 1.0 / 60.0 // 60 FPS max
+    private let motionManager = CMMotionManager()
+    private var lastCaptureOrientation: AVCaptureVideoOrientation?
 
     var videoFileURL: URL?
     private let saneMaxZoomFactor: CGFloat = 25.5
@@ -338,6 +359,16 @@ extension CameraController {
                 return
             }
 
+            // Start accelerometer
+            var startedAccelerometer = false
+            if self.motionManager.isAccelerometerAvailable {
+                self.motionManager.accelerometerUpdateInterval = 1.0 / 60.0
+                if !self.motionManager.isAccelerometerActive {
+                    self.motionManager.startAccelerometerUpdates()
+                    startedAccelerometer = true
+                }
+            }
+
             do {
                 // Create session if needed
                 if self.captureSession == nil {
@@ -426,6 +457,9 @@ extension CameraController {
                     completionHandler(nil)
                 }
             } catch {
+                if startedAccelerometer {
+                    self.motionManager.stopAccelerometerUpdates()
+                }
                 DispatchQueue.main.async {
                     completionHandler(error)
                 }
@@ -900,6 +934,12 @@ extension CameraController {
             return
         }
 
+        // Make sure capture is getting the physical orientation not interface orientation
+        if let connection = photoOutput.connection(with: .video) {
+            let captureOrientation = self.getPhysicalOrientation()
+            self.lastCaptureOrientation = captureOrientation
+            connection.videoOrientation = captureOrientation
+        }
         let settings = AVCapturePhotoSettings()
         // Configure photo capture settings optimized for speed
         // Only use high res if explicitly requesting large dimensions
@@ -1285,11 +1325,28 @@ extension CameraController {
     }
 
     func cropImageToAspectRatio(image: UIImage, aspectRatio: String) -> UIImage? {
-        guard let ratio = parseAspectRatio(aspectRatio) else {
+        let components = aspectRatio.split(separator: ":").compactMap {Float(String($0))}
+        guard components.count == 2 else {
             print("[CameraPreview] cropImageToAspectRatio - Failed to parse aspect ratio: \(aspectRatio)")
             return image
         }
 
+        // Use physical orientation for capture works with portrait lock
+        let orientation = self.lastCaptureOrientation ?? self.getPhysicalOrientation()
+        let isPortrait = (orientation == .portrait || orientation == .portraitUpsideDown)
+
+        let ratioWidth: CGFloat
+        let ratioHeight: CGFloat
+        if isPortrait {
+            // For portrait 4:3 becomes 3:4, 16:9 becomes 9:16
+            ratioWidth = CGFloat(components[1])
+            ratioHeight = CGFloat(components[0])
+        } else {
+            // For landscape keep original
+            ratioWidth = CGFloat(components[0])
+            ratioHeight = CGFloat(components[1])
+        }
+
         // Only normalize the image orientation if it's not already correct
         let normalizedImage: UIImage
         if image.imageOrientation == .up {
@@ -1302,10 +1359,10 @@ extension CameraController {
 
         let imageSize = normalizedImage.size
         let imageAspectRatio = imageSize.width / imageSize.height
-        let targetAspectRatio = ratio.width / ratio.height
+        let targetAspectRatio = ratioWidth / ratioHeight
 
         print("[CameraPreview] cropImageToAspectRatio - Original image: \(imageSize.width)x\(imageSize.height) (ratio: \(imageAspectRatio))")
-        print("[CameraPreview] cropImageToAspectRatio - Target ratio: \(ratio.width):\(ratio.height) (ratio: \(targetAspectRatio))")
+        print("[CameraPreview] cropImageToAspectRatio - Target ratio: \(ratioWidth):\(ratioHeight) (ratio: \(targetAspectRatio))")
 
         var cropRect: CGRect
 
@@ -1698,11 +1755,15 @@ extension CameraController {
             // Set the focus point
             device.focusPointOfInterest = point
 
-            // Also set exposure point if supported
-            if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose) {
-                device.exposureMode = .autoExpose
-                device.setExposureTargetBias(0.0) { _ in }
-                device.exposurePointOfInterest = point
+            // Skip exposure point if exposure locked
+            if device.exposureMode != .locked {
+
+                // Also set exposure point if supported
+                if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose) {
+                    device.exposureMode = .autoExpose
+                    device.setExposureTargetBias(0.0) { _ in }
+                    device.exposurePointOfInterest = point
+                }
             }
 
             device.unlockForConfiguration()
@@ -1878,6 +1939,7 @@ extension CameraController {
             captureSession.outputs.forEach { captureSession.removeOutput($0) }
         }
 
+        self.motionManager.stopAccelerometerUpdates()
         self.previewLayer?.removeFromSuperlayer()
         self.previewLayer = nil
 
@@ -2103,18 +2165,8 @@ extension CameraController {
         //
         if let connection = fileVideoOutput.connection(with: .video) {
             if connection.isEnabled == false { connection.isEnabled = true }
-            switch UIDevice.current.orientation {
-            case .landscapeRight:
-                connection.videoOrientation = .landscapeLeft
-            case .landscapeLeft:
-                connection.videoOrientation = .landscapeRight
-            case .portrait:
-                connection.videoOrientation = .portrait
-            case .portraitUpsideDown:
-                connection.videoOrientation = .portraitUpsideDown
-            default:
-                connection.videoOrientation = .portrait
-            }
+            // Goes off accelerometer now
+            connection.videoOrientation = self.getPhysicalOrientation()
         }
 
         let identifier = UUID()
@@ -2176,12 +2228,14 @@ extension CameraController: UIGestureRecognizerDelegate {
                 device.focusPointOfInterest = CGPoint(x: CGFloat(devicePoint?.x ?? 0), y: CGFloat(devicePoint?.y ?? 0))
                 device.focusMode = focusMode
             }
-
-            let exposureMode = AVCaptureDevice.ExposureMode.autoExpose
-            if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(exposureMode) {
-                device.exposurePointOfInterest = CGPoint(x: CGFloat(devicePoint?.x ?? 0), y: CGFloat(devicePoint?.y ?? 0))
-                device.exposureMode = exposureMode
-                device.setExposureTargetBias(0.0) { _ in }
+            // Skip exposure point if locked
+            if device.exposureMode != .locked {
+                let exposureMode = AVCaptureDevice.ExposureMode.autoExpose
+                if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(exposureMode) {
+                    device.exposurePointOfInterest = CGPoint(x: CGFloat(devicePoint?.x ?? 0), y: CGFloat(devicePoint?.y ?? 0))
+                    device.exposureMode = exposureMode
+                    device.setExposureTargetBias(0.0) { _ in }
+                }
             }
         } catch {
             debugPrint(error)

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -34,7 +34,7 @@ extension UIWindow {
  */
 @objc(CameraPreview)
 public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelegate {
-    private let pluginVersion: String = "8.0.9"
+    private let pluginVersion: String = "8.0.11"
     public let identifier = "CameraPreviewPlugin"
     public let jsName = "CameraPreview"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -83,6 +83,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
     private var isInitializing: Bool = false
     private var isInitialized: Bool = false
     private var backgroundSession: AVCaptureSession?
+    private var isGeneratingDeviceOrientationNotifications: Bool = false
 
     var previewView: UIView!
     var cameraPosition = String()
@@ -679,7 +680,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                     self.cameraController.stopRequestedAfterCapture = false
                     self.cameraController.cleanup()
                     NotificationCenter.default.removeObserver(self, name: UIDevice.orientationDidChangeNotification, object: nil)
-                    UIDevice.current.endGeneratingDeviceOrientationNotifications()
+                    if self.isGeneratingDeviceOrientationNotifications {
+                        UIDevice.current.endGeneratingDeviceOrientationNotifications()
+                        self.isGeneratingDeviceOrientationNotifications = false
+                    }
                     self.isInitialized = false
                     self.isInitializing = false
                 }
@@ -779,11 +783,14 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                 }
 
                 DispatchQueue.main.async {
-                    UIDevice.current.beginGeneratingDeviceOrientationNotifications()
-                    NotificationCenter.default.addObserver(self,
-                                                           selector: #selector(self.handleOrientationChange),
-                                                           name: UIDevice.orientationDidChangeNotification,
-                                                           object: nil)
+                    if self.rotateWhenOrientationChanged == true {
+                        UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+                        self.isGeneratingDeviceOrientationNotifications = true
+                        NotificationCenter.default.addObserver(self,
+                                                               selector: #selector(self.handleOrientationChange),
+                                                               name: UIDevice.orientationDidChangeNotification,
+                                                               object: nil)
+                    }
                     self.completeStartCamera(call: call)
                 }
             }
@@ -970,7 +977,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             // Remove notification observers regardless
             NotificationCenter.default.removeObserver(self)
             NotificationCenter.default.removeObserver(self, name: UIDevice.orientationDidChangeNotification, object: nil)
-            UIDevice.current.endGeneratingDeviceOrientationNotifications()
+            if self.isGeneratingDeviceOrientationNotifications {
+                UIDevice.current.endGeneratingDeviceOrientationNotifications()
+                self.isGeneratingDeviceOrientationNotifications = false
+            }
 
             if self.cameraController.isCapturingPhoto && !force {
                 // Defer heavy cleanup until capture callback completes (only if not forcing)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "8.0.9",
+  "version": "8.0.11",
   "description": "Camera preview",
   "license": "MPL-2.0",
   "repository": {