@momo-kits/camerakit 0.168.1-beta.2 → 0.168.1-beta.20

package/ios/ReactNativeCameraKit/CameraDirection.swift

@@ -0,0 +1,143 @@
+// File: packages/react-native-camera-kit/ios/ReactNativeCameraKit/CameraDirection.swift
+// Created At: 2026-10-22 10:00:00 +07:00
+// Created By: AI
+// AI Agent: Claude Code
+// Model: claude-opus-5-5
+
+// AI-GENERATED START: keep the camera backward-facing and upright (iPhone Duo), ported from the host app
+import AVFoundation
+import AVKit
+import ImageIO
+import UIKit
+
+/// Keeps the back camera on a camera that points away from the person, on every iPhone.
+///
+/// On iPhone Duo the direction a camera faces depends on the display the app is on, and opening or
+/// closing the device moves the app to the other display. `AVCaptureDeviceDirectionCoordinator`
+/// reports which cameras face backward relative to the preview view: the observer keeps the current
+/// camera while it still faces backward and otherwise hands back a replacement. On an iPhone with
+/// one display the rear cameras always face backward, so the handler never asks for a change.
+///
+/// Kit-internal copy of the host's `ScannerCameraDirectionObserver` (ios/EvitanSwiftUI/Camera).
+final class CameraDirectionObserver {
+    /// A replacement camera: its `uniqueID`, and whether it sits on the front (preview stays unmirrored).
+    typealias Replacement = (uniqueID: String, isFrontPosition: Bool)
+
+    private var coordinator: AnyObject?
+
+    /// Starts observing in relation to `previewView`; call on the main queue once the view is onscreen.
+    /// - Parameters:
+    ///   - deviceTypes: the rear camera types the camera captures from, in order of preference.
+    ///   - currentCameraID: the `uniqueID` of the camera in use.
+    ///   - onReplace: called on the main queue when the current camera no longer faces backward.
+    func start(
+        previewView: UIView,
+        deviceTypes: [AVCaptureDevice.DeviceType],
+        currentCameraID: @escaping () -> String?,
+        onReplace: @escaping (Replacement) -> Void
+    ) {
+#if canImport(UIKit, _version: 9127.0.85.28)
+        guard #available(iOS 27.1, *), coordinator == nil else { return }
+        // the two physical front cameras stand in for the virtual front camera, which the coordinator skips
+        let observedTypes = deviceTypes + [.builtInOuterUltraWideCamera, .builtInInnerUltraWideCamera]
+        coordinator = AVCaptureDeviceDirectionCoordinator(view: previewView, deviceTypes: observedTypes) { map in
+            let backward = map.backwardFacingDeviceDescriptors
+            if let current = currentCameraID(), backward.contains(where: { $0.uniqueID == current }) { return }
+            let rank = { (type: AVCaptureDevice.DeviceType) in
+                observedTypes.firstIndex(of: type) ?? observedTypes.count
+            }
+            // AVFoundation is not called here: the caller resolves the descriptor on its session queue
+            guard let replacement = backward.min(by: { rank($0.deviceType) < rank($1.deviceType) }) else { return }
+            onReplace((replacement.uniqueID, replacement.position == .front))
+        }
+#endif
+    }
+
+    func stop() {
+        coordinator = nil
+    }
+}
+
+/// Rotation that keeps a camera's captured frames and preview level with the horizon.
+///
+/// Wraps `AVCaptureDevice.RotationCoordinator` (iOS 17+). It reads gravity and the display the app is
+/// on, so the angle stays right on iPhone Duo where moving between displays changes it; deriving it
+/// from `UIDevice.orientation` or the interface orientation does not. Create one per camera.
+///
+/// Kit-internal copy of the host's `CaptureRotationTracker` (ios/EvitanSwiftUI/Camera).
+///
+/// Preview and capture angles are observed separately. They change independently: on the iPhone Duo
+/// inner display the interface ignores a portrait-only lock and lays out in landscape, which moves the
+/// preview angle while the capture angle (gravity) stays the same.
+final class CaptureRotationTracker {
+    private var coordinator: AnyObject?
+    private var captureObservation: NSKeyValueObservation?
+    private var previewObservation: NSKeyValueObservation?
+    private let lock = NSLock()
+    private var latestCaptureAngle: CGFloat?
+
+    /// The capture angle in degrees (0, 90, 180, 270); nil before iOS 17 or before the first reading.
+    /// Safe to read from the session and sample buffer queues.
+    var captureAngle: CGFloat? {
+        lock.lock()
+        defer { lock.unlock() }
+        return latestCaptureAngle
+    }
+
+    /// The current preview angle in degrees; nil before iOS 17 or when not tracking. Main queue only.
+    /// Read it on layout too: the coordinator reports 0 while the layer is outside a view hierarchy.
+    var previewAngle: CGFloat? {
+        guard #available(iOS 17.0, *),
+              let rotationCoordinator = coordinator as? AVCaptureDevice.RotationCoordinator else { return nil }
+        return rotationCoordinator.videoRotationAngleForHorizonLevelPreview
+    }
+
+    /// Starts tracking `device`; call on the main queue, once `previewLayer` is in a window.
+    /// `onPreviewAngle` receives the preview angle on the main queue.
+    func start(device: AVCaptureDevice, previewLayer: CALayer?, onPreviewAngle: ((CGFloat) -> Void)? = nil) {
+        guard #available(iOS 17.0, *) else { return }
+        stop()
+        let rotationCoordinator = AVCaptureDevice.RotationCoordinator(device: device, previewLayer: previewLayer)
+        coordinator = rotationCoordinator
+        store(rotationCoordinator.videoRotationAngleForHorizonLevelCapture)
+        onPreviewAngle?(rotationCoordinator.videoRotationAngleForHorizonLevelPreview)
+        let captureKeyPath = \AVCaptureDevice.RotationCoordinator.videoRotationAngleForHorizonLevelCapture
+        captureObservation = rotationCoordinator.observe(captureKeyPath) { [weak self] coordinator, _ in
+            self?.store(coordinator.videoRotationAngleForHorizonLevelCapture)
+        }
+        // the coordinator delivers KVO on the main queue; hop only if that ever changes
+        let previewKeyPath = \AVCaptureDevice.RotationCoordinator.videoRotationAngleForHorizonLevelPreview
+        previewObservation = rotationCoordinator.observe(previewKeyPath) { coordinator, _ in
+            let angle = coordinator.videoRotationAngleForHorizonLevelPreview
+            if Thread.isMainThread {
+                onPreviewAngle?(angle)
+            } else {
+                DispatchQueue.main.async { onPreviewAngle?(angle) }
+            }
+        }
+    }
+
+    func stop() {
+        captureObservation = nil
+        previewObservation = nil
+        coordinator = nil
+        store(nil)
+    }
+
+    /// The Vision / `CGImage` orientation of a frame captured at `angle`.
+    static func imageOrientation(forCaptureAngle angle: CGFloat, isMirrored: Bool) -> CGImagePropertyOrientation {
+        switch (Int(angle.rounded()) % 360 + 360) % 360 {
+        case 90: return isMirrored ? .leftMirrored : .right
+        case 180: return isMirrored ? .downMirrored : .down
+        case 270: return isMirrored ? .rightMirrored : .left
+        default: return isMirrored ? .upMirrored : .up
+        }
+    }
+
+    private func store(_ angle: CGFloat?) {
+        lock.lock()
+        latestCaptureAngle = angle
+        lock.unlock()
+    }
+}
+// AI-GENERATED END: keep the camera backward-facing and upright (iPhone Duo), ported from the host app

package/ios/ReactNativeCameraKit/CameraView.swift

@@ -132,6 +132,13 @@ public class CameraView: UIView {
 
         focusInterfaceView.delegate = camera
 
+        // AI-GENERATED START: scan area follows the frame's layout (resize, rotation, iPhone Duo fold)
+        scannerInterfaceView.onFrameChange = { [weak self] frame in
+            guard let self else { return }
+            self.camera.update(scannerFrameSize: self.showFrame ? frame : nil)
+        }
+        // AI-GENERATED END: scan area follows the frame's layout (resize, rotation, iPhone Duo fold)
+
         handleCameraPermission()
 
         configureHardwareInteraction()
@@ -184,8 +191,9 @@ public class CameraView: UIView {
         camera.previewView.frame = bounds
 
         scannerInterfaceView.frame = bounds
-        // If frame size changes, we have to update the scanner
-        camera.update(scannerFrameSize: showFrame ? scannerInterfaceView.frameSize : nil)
+        // AI-GENERATED START: the scanner reports its frame from layoutSubviews (onFrameChange)
+        scannerInterfaceView.setNeedsLayout()
+        // AI-GENERATED END: the scanner reports its frame from layoutSubviews (onFrameChange)
 
         focusInterfaceView.frame = bounds
 
@@ -274,8 +282,9 @@ public class CameraView: UIView {
 
         if changedProps.contains("barcodeFrameSize"), let barcodeFrameSize, showFrame, scanBarcode {
             if let width = barcodeFrameSize["width"] as? CGFloat, let height = barcodeFrameSize["height"] as? CGFloat {
+                // AI-GENERATED START: the new frame reaches the camera from layoutSubviews (onFrameChange)
                 scannerInterfaceView.update(frameSize: CGSize(width: width, height: height))
-                camera.update(scannerFrameSize: showFrame ? scannerInterfaceView.frameSize : nil)
+                // AI-GENERATED END: the new frame reaches the camera from layoutSubviews (onFrameChange)
             }
         }
 

package/ios/ReactNativeCameraKit/RealCamera.swift

@@ -70,6 +70,27 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
     private var zoomStartedAt: Double = 1.0
 
+    // AI-GENERATED START: backward-facing, upright camera when iPhone Duo folds or unfolds
+    private let directionObserver = CameraDirectionObserver()
+    private let rotationTracker = CaptureRotationTracker()
+    /// The camera type JS asked for (sessionQueue only). On iPhone Duo the "back" camera can be a
+    /// front-position device, so the input's `position` no longer tells which type is in use.
+    private var cameraType: CameraType?
+    /// Main queue only: whether the direction coordinator runs, and the camera it compares against.
+    private var followsBackwardDirection = false
+    private var activeDevice: AVCaptureDevice?
+    private var lastPreviewSize: CGSize = .zero
+    /// Rear camera types the back camera captures from, in order of preference.
+    private static let rearDeviceTypes: [AVCaptureDevice.DeviceType] = [
+        .builtInWideAngleCamera,
+        .builtInTelephotoCamera,
+        .builtInUltraWideCamera,
+        .builtInDualCamera,
+        .builtInDualWideCamera,
+        .builtInTripleCamera
+    ]
+    // AI-GENERATED END: backward-facing, upright camera when iPhone Duo folds or unfolds
+
     // MARK: - Lifecycle
 
     override init() {
@@ -87,9 +108,45 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         //      crash class is closed by construction, on every device.
         cameraPreview.session = session
         cameraPreview.previewLayer.videoGravity = .resizeAspectFill
+
+        // AI-GENERATED START: start the direction coordinator only once the preview is onscreen
+        cameraPreview.onWindowChange = { [weak self] window in
+            guard let self else { return }
+            if window == nil {
+                self.directionObserver.stop()
+            } else {
+                // a rotation coordinator made while the layer was off-window reports a 0° preview for good
+                if let activeDevice = self.activeDevice {
+                    self.trackRotation(of: activeDevice)
+                }
+                self.startDirectionObserverIfNeeded()
+            }
+        }
+        // AI-GENERATED END: start the direction coordinator only once the preview is onscreen
+
+        // AI-GENERATED START: re-read the preview angle on layout (rotation, iPhone Duo fold/unfold, display switch)
+        cameraPreview.onLayout = { [weak self] in
+            guard let self else { return }
+            if let angle = self.rotationTracker.previewAngle {
+                self.applyPreviewAngle(angle)
+            }
+            // metadataOutputRectConverted also depends on the layer's size
+            let size = self.cameraPreview.bounds.size
+            if size != self.lastPreviewSize {
+                self.lastPreviewSize = size
+                self.refreshRectOfInterest()
+            }
+        }
+        // AI-GENERATED END: re-read the preview angle on layout (rotation, iPhone Duo fold/unfold, display switch)
     }
 
     func cameraRemovedFromSuperview() {
+        // AI-GENERATED START: backward-facing, upright camera when iPhone Duo folds or unfolds
+        directionObserver.stop()
+        rotationTracker.stop()
+        // AI-GENERATED END: backward-facing, upright camera when iPhone Duo folds or unfolds
+
+
         sessionQueue.async { [weak self] in
             guard let self, self.setupResult == .success else { return }
 
@@ -106,6 +163,9 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
 #if !targetEnvironment(macCatalyst)
         motionManager?.stopAccelerometerUpdates()
+        // AI-GENERATED START: display-relative gravity for onOrientationChange (iPhone Duo)
+        motionManager?.stopDeviceMotionUpdates()
+        // AI-GENERATED END: display-relative gravity for onOrientationChange (iPhone Duo)
 
         NotificationCenter.default.removeObserver(self, name: UIDevice.orientationDidChangeNotification, object: UIDevice.current)
 
@@ -160,10 +220,17 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             // pure connection-property write (no session config transaction → no race
             // with startRunning). The connection exists because configureSession has
             // committed the video input above.
+            // AI-GENERATED START: rotation coordinator angle, which follows the display iPhone Duo uses
+            let videoDevice = self.videoDeviceInput?.device
             DispatchQueue.main.async { [weak self] in
                 guard let self else { return }
-                self.setVideoOrientationToInterfaceOrientation()
+                if #available(iOS 17.0, *), let videoDevice {
+                    self.followDevice(videoDevice, cameraType: cameraType)
+                } else {
+                    self.setVideoOrientationToInterfaceOrientation()
+                }
             }
+            // AI-GENERATED END: rotation coordinator angle, which follows the display iPhone Duo uses
 
             // Order matches the previous behaviour: start, then observe, then torch.
             self.startSessionIfNeeded()
@@ -197,6 +264,9 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         }
         session.addInput(videoDeviceInput)
         self.videoDeviceInput = videoDeviceInput
+        // AI-GENERATED START: remember the requested type, the input's position can differ on iPhone Duo
+        self.cameraType = cameraType
+        // AI-GENERATED END: remember the requested type, the input's position can differ on iPhone Duo
         self.resetZoom(forDevice: videoDevice)
 
         // 2. Preset — set inside the transaction with the device input already
@@ -428,9 +498,11 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     func update(cameraType: CameraType) {
         sessionQueue.async { [weak self] in
             guard let self else { return }
-            if self.videoDeviceInput?.device.position == cameraType.avPosition {
+            // AI-GENERATED START: compare the requested type, the input's position can differ on iPhone Duo
+            if self.cameraType == cameraType {
                 return
             }
+            // AI-GENERATED END: compare the requested type, the input's position can differ on iPhone Duo
 
             // Avoid chaining device inputs when camera input is denied by the user, since both front and rear vido input devices will be nil
             guard self.setupResult == .success,
@@ -442,27 +514,131 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
             self.removeObservers()
             self.beginConfiguration()
-            defer { self.commitConfiguration() }
 
             // Remove the existing device input first, since using the front and back camera simultaneously is not supported.
             self.session.removeInput(currentViewDeviceInput)
 
-            if self.session.canAddInput(videoDeviceInput) {
+            // AI-GENERATED START: track the requested type and restore mirroring after an iPhone Duo swap
+            let didSwitch = self.session.canAddInput(videoDeviceInput)
+            if didSwitch {
                 self.session.addInput(videoDeviceInput)
                 self.resetZoom(forDevice: videoDevice)
                 self.videoDeviceInput = videoDeviceInput
+                self.cameraType = cameraType
+                self.applyVideoMirroring(isFrontFacingBackward: false)
             } else {
                 // If it fails, put back current camera
                 self.session.addInput(currentViewDeviceInput)
             }
 
             self.addObservers()
+            // committed before the main queue reads the new preview connection
+            self.commitConfiguration()
 
             // We need to reapply the configuration after reloading the camera
             self.update(torchMode: self.torchMode)
+
+            guard didSwitch else { return }
+            DispatchQueue.main.async { [weak self] in
+                self?.followDevice(videoDevice, cameraType: cameraType)
+            }
+            // AI-GENERATED END: track the requested type and restore mirroring after an iPhone Duo swap
+        }
+    }
+
+    // AI-GENERATED START: backward-facing, upright camera when iPhone Duo folds or unfolds
+    /// Follows `device`'s rotation and, for the back camera, which way it faces; call on the main queue.
+    private func followDevice(_ device: AVCaptureDevice, cameraType: CameraType) {
+        activeDevice = device
+        followsBackwardDirection = cameraType == .back
+        trackRotation(of: device)
+        if followsBackwardDirection {
+            startDirectionObserverIfNeeded()
+        } else {
+            directionObserver.stop()
+        }
+    }
+
+    /// Starts following which cameras face backward relative to the preview; call on the main queue.
+    private func startDirectionObserverIfNeeded() {
+        guard followsBackwardDirection, cameraPreview.window != nil else { return }
+        directionObserver.start(
+            previewView: cameraPreview,
+            deviceTypes: Self.rearDeviceTypes,
+            currentCameraID: { [weak self] in self?.activeDevice?.uniqueID },
+            onReplace: { [weak self] replacement in self?.switchCamera(to: replacement) }
+        )
+    }
+
+    /// Swaps the video input for a camera that faces backward again after iPhone Duo folded or unfolded.
+    private func switchCamera(to replacement: CameraDirectionObserver.Replacement) {
+        sessionQueue.async { [weak self] in
+            guard let self, self.setupResult == .success, self.cameraType == .back,
+                  let currentInput = self.videoDeviceInput,
+                  currentInput.device.uniqueID != replacement.uniqueID,
+                  let device = AVCaptureDevice(uniqueID: replacement.uniqueID),
+                  let newInput = try? AVCaptureDeviceInput(device: device) else {
+                return
+            }
+
+            self.removeObservers()
+            self.beginConfiguration()
+            self.session.removeInput(currentInput)
+            // decide from a local flag, not by re-reading the shared input
+            let didSwitch = self.session.canAddInput(newInput)
+            if didSwitch {
+                self.session.addInput(newInput)
+                self.videoDeviceInput = newInput
+                // a front camera facing backward is shown and captured unmirrored, like a rear camera
+                self.applyVideoMirroring(isFrontFacingBackward: replacement.isFrontPosition)
+            } else if self.session.canAddInput(currentInput) {
+                self.session.addInput(currentInput)
+            }
+            self.addObservers()
+            self.commitConfiguration()
+
+            self.update(torchMode: self.torchMode)
+            guard didSwitch else { return }
+            self.resetZoom(forDevice: device)
+            DispatchQueue.main.async { [weak self] in
+                self?.followDevice(device, cameraType: .back)
+            }
+        }
+    }
+
+    /// Follows the capture and preview angles of `device`; call on the main queue.
+    private func trackRotation(of device: AVCaptureDevice) {
+        rotationTracker.start(device: device, previewLayer: cameraPreview.previewLayer) { [weak self] angle in
+            self?.applyPreviewAngle(angle)
         }
     }
 
+    /// Rotates the preview connection to `angle` when it differs; call on the main queue.
+    private func applyPreviewAngle(_ angle: CGFloat) {
+        guard #available(iOS 17.0, *),
+              let connection = cameraPreview.previewLayer.connection,
+              connection.videoRotationAngle != angle,
+              connection.isVideoRotationAngleSupported(angle) else {
+            return
+        }
+        connection.videoRotationAngle = angle
+        // metadataOutputRectConverted depends on the preview connection's angle
+        refreshRectOfInterest()
+    }
+
+    /// A front camera facing backward (iPhone Duo) stays unmirrored; every other camera gets the system
+    /// default back. MUST run on `sessionQueue`, inside a configuration transaction.
+    private func applyVideoMirroring(isFrontFacingBackward: Bool) {
+        assertOnSessionQueue()
+        session.connections.filter(\.isVideoMirroringSupported).forEach { connection in
+            connection.automaticallyAdjustsVideoMirroring = !isFrontFacingBackward
+            if isFrontFacingBackward {
+                connection.isVideoMirrored = false
+            }
+        }
+    }
+    // AI-GENERATED END: backward-facing, upright camera when iPhone Duo folds or unfolds
+
     func update(resizeMode: ResizeMode) {
         DispatchQueue.main.async {
             switch resizeMode {
@@ -524,10 +700,17 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                     return
                 }
 
-                // Set video orientation if available
-                if let videoPreviewLayerOrientation {
+                // AI-GENERATED START: rotation coordinator angle, which follows the display iPhone Duo uses
+                // Gravity alone can't tell which display iPhone Duo uses, so iOS 17+ takes the rotation
+                // coordinator's horizon-level angle; the accelerometer value only covers older systems.
+                if #available(iOS 17.0, *), let captureAngle = self.rotationTracker.captureAngle {
+                    if photoOutputConnection.isVideoRotationAngleSupported(captureAngle) {
+                        photoOutputConnection.videoRotationAngle = captureAngle
+                    }
+                } else if let videoPreviewLayerOrientation {
                     photoOutputConnection.videoOrientation = videoPreviewLayerOrientation
                 }
+                // AI-GENERATED END: rotation coordinator angle, which follows the display iPhone Duo uses
 
                 // Pause OCR + barcode work on the session queue, right before capture.
                 self.pauseNonEssentialOutputs()
@@ -594,28 +777,49 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         guard self.scannerFrameSize != scannerFrameSize else { return }
         self.sessionQueue.async {
             self.scannerFrameSize = scannerFrameSize
-            if !self.session.isRunning {
-                return
-            }
+            // AI-GENERATED START: recompute the scan area when the frame or the preview angle changes
+            self.applyRectOfInterest()
+        }
+    }
 
-            DispatchQueue.main.async {
-                var visibleRect: CGRect?
-                if let scannerFrameSize, scannerFrameSize != .zero {
-                    visibleRect = self.cameraPreview.previewLayer.metadataOutputRectConverted(fromLayerRect: scannerFrameSize)
-                }
+    /// Re-derives `rectOfInterest` from the scanner frame. Call whenever the frame or the preview
+    /// connection's angle changes: `metadataOutputRectConverted` depends on both.
+    private func refreshRectOfInterest() {
+        sessionQueue.async { [weak self] in
+            self?.applyRectOfInterest()
+        }
+    }
 
-                self.sessionQueue.async {
-                    if self.metadataOutput.rectOfInterest == visibleRect {
-                        return
-                    }
+    /// MUST run on `sessionQueue`.
+    private func applyRectOfInterest() {
+        assertOnSessionQueue()
+        if !session.isRunning {
+            return
+        }
+        let scannerFrameSize = self.scannerFrameSize
 
-                    self.metadataOutput.rectOfInterest = visibleRect ?? CGRect(x: 0, y: 0, width: 1, height: 1)
-                    // We need to reapply the configuration after touching the metadataOutput
-                    self.update(torchMode: self.torchMode)
+        // metadataOutputRectConverted must be read on the main thread.
+        DispatchQueue.main.async {
+            var visibleRect: CGRect?
+            if let scannerFrameSize, scannerFrameSize != .zero {
+                visibleRect = self.cameraPreview.previewLayer
+                    .metadataOutputRectConverted(fromLayerRect: scannerFrameSize)
+            }
+
+            self.sessionQueue.async {
+                // a photo capture pauses scanning; resumeNonEssentialOutputs restores the rect afterwards
+                guard self.inProgressPhotoCaptureDelegates.isEmpty,
+                      self.metadataOutput.rectOfInterest != visibleRect else {
+                    return
                 }
+
+                self.metadataOutput.rectOfInterest = visibleRect ?? CGRect(x: 0, y: 0, width: 1, height: 1)
+                // We need to reapply the configuration after touching the metadataOutput
+                self.update(torchMode: self.torchMode)
             }
         }
     }
+    // AI-GENERATED END: recompute the scan area when the frame or the preview angle changes
 
 
     func isTextDetectionEnabled(_ isEnabled: Bool, onTextRead: ((String) -> Void)?) {
@@ -651,11 +855,19 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         if now.timeIntervalSince(lastTextProcess) < textThrottle { return }
         lastTextProcess = now
 
+        // AI-GENERATED START: rotation coordinator angle, so OCR reads text in sideways or upside-down frames
+        let orientation = rotationTracker.captureAngle.map {
+            CaptureRotationTracker.imageOrientation(forCaptureAngle: $0, isMirrored: connection.isVideoMirrored)
+        } ?? .up
+        // AI-GENERATED END: rotation coordinator angle, so OCR reads text in sideways or upside-down frames
+
         globalOCRQueue.async {
             guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
             var requestOptions: [VNImageOption: Any] = [:]
 
-            let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: .up, options: requestOptions)
+            let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer,
+                                                orientation: orientation,
+                                                options: requestOptions)
             do {
                 try handler.perform([request])
             } catch {
@@ -713,6 +925,16 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     }
 
     private func getBestDevice(for cameraType: CameraType) -> AVCaptureDevice? {
+        // AI-GENERATED START: same rear camera set the host scanner uses; the wide angle stays first
+        if cameraType == .back,
+           let device = AVCaptureDevice.DiscoverySession(
+               deviceTypes: Self.rearDeviceTypes,
+               mediaType: .video,
+               position: .back
+           ).devices.first {
+            return device
+        }
+        // AI-GENERATED END: same rear camera set the host scanner uses; the wide angle stays first
         if let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: cameraType.avPosition) {
             return device // single-lens/physical device
         }
@@ -780,6 +1002,22 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         motionManager?.accelerometerUpdateInterval = 0.2
         motionManager?.gyroUpdateInterval = 0.2
 
+        // AI-GENERATED START: display-relative gravity for onOrientationChange (iPhone Duo)
+        // The accelerometer reports in the hardware frame, a quarter turn off from the UI on the iPhone Duo
+        // inner display. Device motion referenced to the preview view arrives corrected for that display.
+#if canImport(UIKit, _version: 9127.0.85.28)
+        if #available(iOS 27.0, *), let motionManager, motionManager.isDeviceMotionAvailable {
+            motionManager.deviceMotionUpdateInterval = 0.2
+            motionManager.deviceMotionBody = cameraPreview
+            motionManager.startDeviceMotionUpdates(to: OperationQueue()) { [weak self] motion, error in
+                guard error == nil, let gravity = motion?.gravity else { return }
+                self?.reportOrientation(from: gravity)
+            }
+            return
+        }
+#endif
+        // AI-GENERATED END: display-relative gravity for onOrientationChange (iPhone Duo)
+
         motionManager?.startAccelerometerUpdates(to: OperationQueue(), withHandler: { [weak self] (accelerometerData, error) -> Void in
             guard let self else { return }
             guard error == nil else {
@@ -791,18 +1029,25 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                 return
             }
 
-            guard let newOrientation = self.deviceOrientation(from: accelerometerData.acceleration),
-                  newOrientation != self.deviceOrientation,
-                  let orientation = Orientation(from: newOrientation) else {
-                return
-            }
-
-            self.deviceOrientation = newOrientation
-            self.onOrientationChange?(["orientation": orientation.rawValue])
+            // AI-GENERATED START: shared with the display-relative device motion path
+            self.reportOrientation(from: accelerometerData.acceleration)
         })
 #endif
     }
 
+    /// Sends `onOrientationChange` when gravity points to a new orientation.
+    private func reportOrientation(from acceleration: CMAcceleration) {
+        guard let newOrientation = deviceOrientation(from: acceleration),
+              newOrientation != deviceOrientation,
+              let orientation = Orientation(from: newOrientation) else {
+            return
+        }
+
+        deviceOrientation = newOrientation
+        onOrientationChange?(["orientation": orientation.rawValue])
+    }
+    // AI-GENERATED END: shared with the display-relative device motion path
+
     private func deviceOrientation(from acceleration: CMAcceleration) -> UIDeviceOrientation? {
         let threshold = 0.75
         if acceleration.x >= threshold {
@@ -866,6 +1111,8 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         resetFocus?()
     }
 
+    // AI-GENERATED START: legacy preview orientation, iOS 17+ uses the rotation coordinator (trackRotation)
+    // AI-GENERATED END: legacy preview orientation, iOS 17+ uses the rotation coordinator (trackRotation)
     private func setVideoOrientationToInterfaceOrientation() {
 #if !targetEnvironment(macCatalyst)
         var interfaceOrientation: UIInterfaceOrientation

package/ios/ReactNativeCameraKit/RealPreviewView.swift

@@ -23,4 +23,25 @@ class RealPreviewView: UIView {
         get { previewLayer.session }
         set { previewLayer.session = newValue }
     }
+
+    // AI-GENERATED START: report when the preview is onscreen, for the camera direction coordinator
+    /// Called on the main queue with the new window, or nil once the preview leaves it.
+    /// `CameraDirectionObserver` needs an onscreen preview view.
+    var onWindowChange: ((UIWindow?) -> Void)?
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        onWindowChange?(window)
+    }
+    // AI-GENERATED END: report when the preview is onscreen, for the camera direction coordinator
+
+    // AI-GENERATED START: re-read the preview angle on layout (rotation, iPhone Duo fold/unfold, display switch)
+    /// Called on the main queue after every layout pass.
+    var onLayout: (() -> Void)?
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        onLayout?()
+    }
+    // AI-GENERATED END: re-read the preview angle on layout (rotation, iPhone Duo fold/unfold, display switch)
 }

package/ios/ReactNativeCameraKit/ScannerInterfaceView.swift

@@ -45,14 +45,28 @@ class ScannerInterfaceView: UIView {
         fatalError("init(coder:) has not been implemented")
     }
 
-    override func draw(_ rect: CGRect) {
-        super.draw(rect)
-
-        frameView.frame = CGRect(x: 0, y: 0, width: barcodeFrameWidth, height: barcodeFrameHeight)
-        frameView.center = center
+    // AI-GENERATED START: lay the frame out in the area clear of the iPhone Duo fold and camera punchout
+    /// Called on the main queue with the frame's rect, in this view's coordinates, after every layout.
+    var onFrameChange: ((CGRect) -> Void)?
+
+    // UIKit re-runs layout when the reserved regions change, so they are re-read here without polling.
+    override func layoutSubviews() {
+        super.layoutSubviews()
+
+        let area = ScannerReservedRegions.availableArea(in: self)
+        let size = CGSize(width: min(barcodeFrameWidth, area.width), height: min(barcodeFrameHeight, area.height))
+        let previousSize = frameView.bounds.size
+        frameView.frame = CGRect(origin: .zero, size: size)
+        frameView.center = CGPoint(x: area.midX, y: area.midY)
+        if previousSize != size {
+            // the corners and laser are laid out in ScannerFrameView.draw(_:)
+            frameView.setNeedsDisplay()
+        }
 
         updateOverlaySize(frameView.frame)
+        onFrameChange?(frameView.frame)
     }
+    // AI-GENERATED END: lay the frame out in the area clear of the iPhone Duo fold and camera punchout
 
     // MARK: - Public
 
@@ -79,20 +93,75 @@ class ScannerInterfaceView: UIView {
     func update(frameSize: CGSize) {
         barcodeFrameWidth = frameSize.width
         barcodeFrameHeight = frameSize.height
-        frameView.setNeedsDisplay()
-        setNeedsDisplay()
+        // AI-GENERATED START: the frame is laid out in layoutSubviews, not draw(_:)
+        setNeedsLayout()
+        // AI-GENERATED END: the frame is laid out in layoutSubviews, not draw(_:)
     }
 
     // MARK: - Private
 
+    // AI-GENERATED START: dim around a frame that is no longer always centered
     private func updateOverlaySize(_ frameRect: CGRect) {
-        topOverlayView.frame = CGRect(x: 0, y: 0, width: frame.size.width, height: frameRect.origin.y)
-        leftOverlayView.frame = CGRect(x: 0, y: frameRect.origin.y, width: (frame.size.width - barcodeFrameWidth) / 2, height: barcodeFrameHeight)
-        rightOverlayView.frame = CGRect(x: (frame.size.width - barcodeFrameWidth) / 2 + barcodeFrameWidth, y: frameRect.origin.y, width: (frame.size.width - barcodeFrameWidth) / 2, height: barcodeFrameHeight)
+        topOverlayView.frame = CGRect(x: 0, y: 0, width: bounds.width, height: frameRect.minY)
+        leftOverlayView.frame = CGRect(x: 0, y: frameRect.minY, width: frameRect.minX, height: frameRect.height)
+        rightOverlayView.frame = CGRect(
+            x: frameRect.maxX,
+            y: frameRect.minY,
+            width: bounds.width - frameRect.maxX,
+            height: frameRect.height)
         bottomOverlayView.frame = CGRect(
             x: 0,
-            y: frameRect.origin.y + barcodeFrameHeight,
-            width: frame.size.width,
-            height: frame.size.height - frameRect.origin.y - barcodeFrameHeight)
+            y: frameRect.maxY,
+            width: bounds.width,
+            height: bounds.height - frameRect.maxY)
+    }
+    // AI-GENERATED END: dim around a frame that is no longer always centered
+}
+
+// AI-GENERATED START: keep the scanner frame clear of iPhone Duo reserved regions
+/// The part of a scanner view the frame, laser and dimmed overlay are laid out in (iOS 27.1+, iPhone Duo):
+/// - `.division`: while partially folded, the frame moves to the trailing (vertical fold) or bottom
+///   (horizontal fold) part, like the host's `FoldPlacement`.
+/// - `.occlusion`: a camera punchout the safe area leaves inside the area pushes only the nearest edge,
+///   like the host's `QRScanReservedRegions`.
+/// The whole view on every other device, and compiled out on SDKs older than iOS 27.1.
+enum ScannerReservedRegions {
+    static func availableArea(in view: UIView) -> CGRect {
+        var area = view.bounds
+#if canImport(UIKit, _version: 9127.0.85.28)
+        if #available(iOS 27.1, *) {
+            let folds = view.reservedRegions(kind: .division).filter(\.isActive).map(\.frame)
+            if let fold = folds.dropFirst().reduce(folds.first, { $0?.union($1) }) {
+                area = placement(avoiding: fold, in: area)
+            }
+            for region in view.reservedRegions(kind: .occlusion) where region.isActive {
+                area = clearing(region.frame, from: area)
+            }
+        }
+#endif
+        return area
+    }
+
+    /// The trailing part of a vertical fold, or the bottom part of a horizontal one.
+    static func placement(avoiding fold: CGRect, in area: CGRect) -> CGRect {
+        guard area.width > 0, area.height > 0 else { return area }
+        if fold.height > fold.width {
+            return area.divided(atDistance: min(max(fold.maxX - area.minX, 0), area.width), from: .minXEdge).remainder
+        }
+        return area.divided(atDistance: min(max(fold.maxY - area.minY, 0), area.height), from: .minYEdge).remainder
+    }
+
+    /// Moves the one edge of `area` that clears `occlusion` with the least content lost.
+    static func clearing(_ occlusion: CGRect, from area: CGRect) -> CGRect {
+        guard area.width > 0, area.height > 0, occlusion.intersects(area) else { return area }
+        let candidates: [(cost: CGFloat, edge: CGRectEdge)] = [
+            (occlusion.maxY - area.minY, .minYEdge),
+            (area.maxY - occlusion.minY, .maxYEdge),
+            (occlusion.maxX - area.minX, .minXEdge),
+            (area.maxX - occlusion.minX, .maxXEdge),
+        ]
+        guard let cut = candidates.min(by: { $0.cost < $1.cost }) else { return area }
+        return area.divided(atDistance: cut.cost, from: cut.edge).remainder
     }
 }
+// AI-GENERATED END: keep the scanner frame clear of iPhone Duo reserved regions

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@momo-kits/camerakit",
-    "version": "0.168.1-beta.2",
+    "version": "0.168.1-beta.20",
     "repository": {
         "type": "git",
         "url": "https://github.com/teslamotors/react-native-camera-kit.git"