@capgo/camera-preview 8.0.9 → 8.0.10

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.10"
     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.10",
   "description": "Camera preview",
   "license": "MPL-2.0",
   "repository": {