@momo-kits/camerakit 0.161.2-beta.2 → 0.161.2-beta.7

package/ios/ReactNativeCameraKit/CKCameraViewComponentView.mm

@@ -84,10 +84,10 @@ static id CKConvertFollyDynamicToId(const folly::dynamic &dyn)
 - (void)prepareView
 {
     _view =  [[CKCameraView alloc] init];
-
+    
     // just need to pass something, it won't really be used on fabric, but it's used to create events (it won't impact sending them)
     _view.reactTag = @-1;
-
+    
     __weak __typeof__(self) weakSelf = self;
 
     [_view setOnReadCode:^(NSDictionary* event) {
@@ -137,7 +137,7 @@ static id CKConvertFollyDynamicToId(const folly::dynamic &dyn)
             std::dynamic_pointer_cast<const facebook::react::CKCameraEventEmitter>(strongSelf->_eventEmitter)->onMRZ({.docMRZ = docMRZ});
           }
     }];
-
+    
     self.contentView = _view;
 }
 
@@ -232,7 +232,7 @@ static id CKConvertFollyDynamicToId(const folly::dynamic &dyn)
     }
     id zoomMode = CKConvertFollyDynamicToId(newProps.zoomMode);
     if (zoomMode != nil) {
-        _view.zoomMode = [zoomMode isEqualToString:@"on"] ? CKZoomModeOn : CKZoomModeOff;
+        _view.zoomMode = [focusMode isEqualToString:@"on"] ? CKZoomModeOn : CKZoomModeOff;
         [changedProps addObject:@"zoomMode"];
     }
     id zoom = CKConvertFollyDynamicToId(newProps.zoom);
@@ -251,8 +251,8 @@ static id CKConvertFollyDynamicToId(const folly::dynamic &dyn)
         _view.barcodeFrameSize = @{@"width": @(barcodeWidth), @"height": @(barcodeHeight)};
         [changedProps addObject:@"barcodeFrameSize"];
     }
-
-
+    
+    
     [super updateProps:props oldProps:oldProps];
     [_view didSetProps:changedProps];
 }
@@ -260,12 +260,6 @@ static id CKConvertFollyDynamicToId(const folly::dynamic &dyn)
 - (void)prepareForRecycle
 {
     [super prepareForRecycle];
-
-    if (_view != nil) {
-        [_view removeFromSuperview];
-        _view = nil;
-    }
-
     [self prepareView];
 }
 

package/ios/ReactNativeCameraKit/CameraManager.swift

@@ -18,8 +18,12 @@ import Foundation
         return CameraView()
     }
 
-    @objc public static func capture(camera: CameraView, options: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-        camera.capture((options as? [String: Any]) ?? [:], onSuccess: { resolve($0) }, onError: { reject("capture_error", $0, nil) })
+    @objc public static func capture(camera: CameraView,
+                       options: NSDictionary,
+                       resolve: @escaping RCTPromiseResolveBlock,
+                       reject: @escaping RCTPromiseRejectBlock) {
+        camera.capture(options as! [String: Any], onSuccess: { resolve($0) },
+                    onError: { reject("capture_error", $0, nil) })
     }
 
     @objc public static func checkDeviceCameraAuthorizationStatus(_ resolve: @escaping RCTPromiseResolveBlock,

package/ios/ReactNativeCameraKit/CameraView.swift

@@ -361,8 +361,8 @@ public class CameraView: UIView {
         let features = detector?.features(in: ciImage)
 
         if let firstFeature = features?.first as? CIQRCodeFeature {
-            if let messageString = firstFeature.messageString {
-                self.onBarcodeRead(barcode: messageString, codeFormat: CodeFormat.qr)
+            if (firstFeature.messageString != nil ) {
+                self.onBarcodeRead(barcode: firstFeature.messageString!, codeFormat: CodeFormat.qr)
             }
             return
         }

package/ios/ReactNativeCameraKit/RealCamera.swift

@@ -22,19 +22,19 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
     private let cameraPreview = RealPreviewView(frame: .zero)
     private let session = AVCaptureSession()
-    private static let sharedSessionQueue = DispatchQueue(label: "com.tesla.react-native-camera-kit.session")
-    private let sessionQueue = RealCamera.sharedSessionQueue
-
+    // Communicate with the session and other session objects on this queue.
+    private let sessionQueue = DispatchQueue(label: "com.tesla.react-native-camera-kit")
+    
     // utilities
     private var setupResult: SetupResult = .notStarted
     private var configurationDepth: Int = 0  // Tracks nested beginConfiguration/commitConfiguration calls
     private var pendingStop: Bool = false    // Queues stop request during configuration
     private var backgroundRecordingId: UIBackgroundTaskIdentifier = .invalid
-
+    
     private var videoDeviceInput: AVCaptureDeviceInput?
     private let photoOutput = AVCapturePhotoOutput()
     private let metadataOutput = AVCaptureMetadataOutput()
-
+    
     private var resizeMode: ResizeMode = .cover
     private var flashMode: FlashMode = .auto
     private var torchMode: TorchMode = .off
@@ -49,40 +49,44 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     private var lastOnZoom: Double?
     private var zoom: Double?
     private var maxZoom: Double?
-
+    
     private var deviceOrientation = UIDeviceOrientation.unknown
     private var motionManager: CMMotionManager?
-
+    
     // KVO observation
     private var adjustingFocusObservation: NSKeyValueObservation?
 
-    private var notificationObservers: [NSObjectProtocol] = []
-
     // Keep delegate objects in memory to avoid collecting them before photo capturing finishes
     private var inProgressPhotoCaptureDelegates = [Int64: PhotoCaptureDelegate]()
-
+    
     private var onTextRead: ((_ text: String) -> Void)?
     private let videoDataOutput = AVCaptureVideoDataOutput()
     private var textRequest: VNRecognizeTextRequest?
     private var textDetectionEnabled = false
     private var lastTextProcess = Date.distantPast
     private let textThrottle: TimeInterval = 0.35 // seconds
-
+    
     private var zoomStartedAt: Double = 1.0
-
+    
     // MARK: - Lifecycle
 
     func cameraRemovedFromSuperview() {
-        sessionQueue.async { [weak self] in
-            guard let self, self.setupResult == .success else { return }
+        sessionQueue.async {
+            if self.setupResult == .success {
+                // Only stop if session is running
+                guard self.session.isRunning else {
+                    self.removeObservers()
+                    return
+                }
 
-            // Stop now if idle/safe, or defer the stop until the open configuration
-            // transaction commits (stopSessionIfNeeded sets pendingStop in that case).
-            self.stopSessionIfNeeded()
+                // If we're currently configuring the session, mark pending stop
+                // and let the configuration completion handle it
+                if self.configurationDepth > 0 {
+                    self.pendingStop = true
+                    return
+                }
 
-            // If the stop was deferred, handlePendingStopIfNeeded() will remove the
-            // observers once the transaction commits; otherwise remove them now.
-            if !self.pendingStop {
+                self.session.stopRunning()
                 self.removeObservers()
             }
         }
@@ -95,120 +99,99 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         UIDevice.current.endGeneratingDeviceOrientationNotifications()
 #endif
     }
-
+    
     deinit {
         removeObservers()
-
-        // Ensure the capture hardware is released even if cameraRemovedFromSuperview()
-        // was never delivered (e.g. a forced React surface cleanup during rapid
-        // mount/unmount). Capture only the session object so the block does not
-        // resurrect `self`.
-        let session = self.session
-        sessionQueue.async {
-            if session.isRunning {
-                session.stopRunning()
-            }
-        }
     }
-
+    
     // MARK: - Public
 
     func setup(cameraType: CameraType, supportedBarcodeType: [CodeFormat]) {
-        sessionQueue.async { [weak self] in
-            guard let self else { return }
-
-            // Idempotency guard: a RealCamera configures its session exactly once.
-            // A fresh instance is created on every mount / Fabric recycle, so this
-            // never blocks a legitimate restart — resuming after stopCamera() is
-            // handled by startCamera() -> startSessionIfNeeded().
-            guard self.setupResult == .notStarted else { return }
-
-            // Configure the WHOLE session (inputs, preset, outputs) inside a single
-            // begin/commit transaction on the session queue. The preset is set here
-            // and never on the main queue, so the startRunning() below can no longer
-            // observe the session mid-configuration from another thread.
-            //
-            // This is the root-cause fix for:
-            // "[AVCaptureSession startRunning] startRunning may not be called between
-            //  calls to beginConfiguration and commitConfiguration".
-            self.setupResult = self.configureSession(cameraType: cameraType,
-                                                     supportedBarcodeType: supportedBarcodeType)
-
-            guard self.setupResult == .success else { return }
-
-            // Order matches the previous behaviour: start, then observe, then torch.
-            self.startSessionIfNeeded()
-            self.addObservers()
-            self.update(torchMode: self.torchMode)
+        
+        // Setup the capture session with priority on basic video preview first
+        sessionQueue.async {
+            self.setupResult = self.setupBasicVideoInput(cameraType: cameraType)
+
+            if self.setupResult == .success {
+                self.session.startRunning()
+
+                self.setupAdditionalOutputs(supportedBarcodeType: supportedBarcodeType)
+
+                self.addObservers()
 
-            // Only the preview LAYER is touched on the main queue. Connecting an
-            // AVCaptureVideoPreviewLayer to a session from the main thread is
-            // sanctioned by AVFoundation (see Apple's AVCam) and does NOT open a
-            // session configuration transaction, so it cannot race startRunning().
-            DispatchQueue.main.async { [weak self] in
-                guard let self else { return }
+                self.update(torchMode: self.torchMode)
+            }
+
+            DispatchQueue.main.async {
                 self.cameraPreview.session = self.session
                 self.cameraPreview.previewLayer.videoGravity = .resizeAspectFill
+                self.session.sessionPreset = .photo
                 self.setVideoOrientationToInterfaceOrientation()
             }
         }
-
-        DispatchQueue.global(qos: .utility).async { [weak self] in
-            self?.initializeMotionManager()
+        
+        DispatchQueue.global(qos: .utility).async {
+            self.initializeMotionManager()
         }
+
     }
 
     // MARK: - Private optimization methods
-
-    /// Configures the video input, session preset and every output in ONE atomic
-    /// transaction. Must be called on `sessionQueue`. Order is significant:
-    /// beginConfiguration -> addInput -> set preset -> addOutputs -> commitConfiguration.
-    private func configureSession(cameraType: CameraType, supportedBarcodeType: [CodeFormat]) -> SetupResult {
-        assertOnSessionQueue()
+    
+    private func setupBasicVideoInput(cameraType: CameraType) -> SetupResult {
         guard let videoDevice = self.getBestDevice(for: cameraType),
               let videoDeviceInput = try? AVCaptureDeviceInput(device: videoDevice) else {
             return .sessionConfigurationFailed
         }
-
-        beginConfiguration()
-        defer { commitConfiguration() }
-
-        // 1. Video input
-        guard session.canAddInput(videoDeviceInput) else {
-            return .sessionConfigurationFailed
-        }
-        session.addInput(videoDeviceInput)
-        self.videoDeviceInput = videoDeviceInput
-        self.resetZoom(forDevice: videoDevice)
-
-        // 2. Preset — set inside the transaction with the device input already
-        // present, so `canSetSessionPreset` reflects the real device. `.photo` is
-        // supported by every camera device; if it somehow is not, we keep whatever
-        // preset the session defaults to rather than crashing.
-        if session.canSetSessionPreset(.photo) {
-            session.sessionPreset = .photo
+        
+        configurationDepth += 1
+        session.beginConfiguration()
+        defer {
+            session.commitConfiguration()
+            configurationDepth -= 1
+            handlePendingStopIfNeeded()
+        }
+        
+        if session.canAddInput(videoDeviceInput) {
+            session.addInput(videoDeviceInput)
+            self.videoDeviceInput = videoDeviceInput
+            self.resetZoom(forDevice: videoDevice)
+            return .success
+        }
+        return .sessionConfigurationFailed
+    }
+    
+    private func setupAdditionalOutputs(supportedBarcodeType: [CodeFormat]) {
+        configurationDepth += 1
+        session.beginConfiguration()
+        defer {
+            session.commitConfiguration()
+            configurationDepth -= 1
+            handlePendingStopIfNeeded()
         }
-
-        // 3. Photo output
+        
+        // Add photo output
         if #available(iOS 13.0, *) {
             if let maxPhotoQualityPrioritization = maxPhotoQualityPrioritization {
                 photoOutput.maxPhotoQualityPrioritization = maxPhotoQualityPrioritization.avQualityPrioritization
             }
         }
+        
         if session.canAddOutput(photoOutput) {
             session.addOutput(photoOutput)
-            // Connection only exists after the output is added to the session.
-            if let photoOutputConnection = self.photoOutput.connection(with: .video),
-               photoOutputConnection.isVideoStabilizationSupported {
-                photoOutputConnection.preferredVideoStabilizationMode = .auto
+
+            if let photoOutputConnection = self.photoOutput.connection(with: .video) {
+                if photoOutputConnection.isVideoStabilizationSupported {
+                    photoOutputConnection.preferredVideoStabilizationMode = .auto
+                }
             }
         }
-
-        // 4. Metadata output for barcode scanning
+        
+        // Add metadata output for barcode scanning
         if self.session.canAddOutput(metadataOutput) {
             self.session.addOutput(metadataOutput)
             metadataOutput.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
-
+            
             let availableTypes = self.metadataOutput.availableMetadataObjectTypes
             let filteredTypes = supportedBarcodeType
                 .map { $0.toAVMetadataObjectType() }
@@ -216,59 +199,39 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
             metadataOutput.metadataObjectTypes = filteredTypes
         }
-
-        // 5. Video data output for text / MRZ detection
-        if textRequest != nil && self.session.canAddOutput(self.videoDataOutput) {
+        
+        // add for text detections
+        if (textRequest != nil && self.session.canAddOutput(self.videoDataOutput)) {
             self.session.addOutput(self.videoDataOutput)
         }
-
-        return .success
     }
-
+    
     // MARK: - Pause / Resume non-essential outputs
-
-    /// Disables OCR + barcode work while a photo is captured.
-    /// MUST be called on `sessionQueue` (these are capture-output mutations).
     private func pauseNonEssentialOutputs() {
-        assertOnSessionQueue()
         videoDataOutput.setSampleBufferDelegate(nil, queue: nil)
         metadataOutput.rectOfInterest = CGRect(x: 0, y: 0, width: 0, height: 0)
     }
-
-    /// Re-enables OCR + barcode work after a capture. May be called from any
-    /// thread (photo-capture completion handlers run on an arbitrary queue), so it
-    /// hops to the main queue only to read preview-layer geometry and applies all
-    /// output mutations back on `sessionQueue`.
+    
     private func resumeNonEssentialOutputs() {
-        sessionQueue.async { [weak self] in
-            guard let self else { return }
-            if self.textDetectionEnabled {
-                self.videoDataOutput.setSampleBufferDelegate(self, queue: globalOCRQueue)
-            }
-
-            guard let scanner = self.scannerFrameSize, scanner != .zero else {
-                self.metadataOutput.rectOfInterest = CGRect(x: 0, y: 0, width: 1, height: 1)
-                return
-            }
-
-            // metadataOutputRectConverted must be read on the main thread.
-            DispatchQueue.main.async { [weak self] in
-                guard let self else { return }
-                let rect = self.cameraPreview.previewLayer.metadataOutputRectConverted(fromLayerRect: scanner)
-                self.sessionQueue.async { [weak self] in
-                    self?.metadataOutput.rectOfInterest = rect
-                }
-            }
+        if textDetectionEnabled {
+            videoDataOutput.setSampleBufferDelegate(self, queue: globalOCRQueue)
+        }
+        // Restore real rect of interest
+        if let scanner = scannerFrameSize, scanner != .zero {
+            metadataOutput.rectOfInterest =
+                cameraPreview.previewLayer.metadataOutputRectConverted(fromLayerRect: scanner)
+        } else {
+            metadataOutput.rectOfInterest = CGRect(x: 0, y: 0, width: 1, height: 1)
         }
     }
-
+    
     func zoomPinchStart() {
         sessionQueue.async {
             guard let videoDevice = self.videoDeviceInput?.device else { return }
             self.zoomStartedAt = videoDevice.videoZoomFactor
         }
     }
-
+    
     func zoomPinchChange(pinchScale: CGFloat) {
         guard !pinchScale.isNaN else { return }
 
@@ -277,7 +240,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
             let desiredZoomFactor = (self.zoomStartedAt / self.defaultZoomFactor(for: videoDevice)) * pinchScale
             let zoomForDevice = self.getValidZoom(forDevice: videoDevice, zoom: desiredZoomFactor)
-
+            
             if zoomForDevice != self.normalizedZoom(for: videoDevice) {
                 // Only trigger zoom changes if it's an uncontrolled component (zoom isn't manually set)
                 // otherwise it's likely to cause issues inf. loops
@@ -288,14 +251,14 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-
+    
     func update(maxZoom: Double?) {
         self.maxZoom = maxZoom
 
         // Re-update zoom value in case the max was increased
         self.update(zoom: self.zoom)
     }
-
+    
     func update(zoom: Double?) {
         sessionQueue.async {
             self.zoom = zoom
@@ -306,7 +269,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             self.setZoomFor(videoDevice, to: zoomForDevice)
         }
     }
-
+    
     /**
      `desiredZoom` can be nil when we want to notify what the zoom factor really is
      */
@@ -327,11 +290,11 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         lastOnZoom = desiredOrCameraZoom
         self.onZoomCallback?(["zoom": desiredOrCameraZoom])
     }
-
+    
     func update(onZoom: RCTDirectEventBlock?) {
         self.onZoomCallback = onZoom
     }
-
+    
     func focus(at touchPoint: CGPoint, focusBehavior: FocusBehavior) {
         DispatchQueue.main.async {
             let devicePoint = self.cameraPreview.previewLayer.captureDevicePointConverted(fromLayerPoint: touchPoint)
@@ -346,7 +309,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                     self.resetFocus = nil
                     self.focusFinished = nil
                 }
-
+                
                 do {
                     try videoDevice.lockForConfiguration()
 
@@ -369,11 +332,11 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-
+    
     func update(onOrientationChange: RCTDirectEventBlock?) {
         self.onOrientationChange = onOrientationChange
     }
-
+    
     func update(torchMode: TorchMode) {
         sessionQueue.async {
             self.torchMode = torchMode
@@ -390,26 +353,29 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-
+    
     func update(flashMode: FlashMode) {
         self.flashMode = flashMode
     }
-
+    
     func update(maxPhotoQualityPrioritization: MaxPhotoQualityPrioritization?) {
         guard #available(iOS 13.0, *) else { return }
-        sessionQueue.async { [weak self] in
-            guard let self else { return }
-            guard maxPhotoQualityPrioritization != self.maxPhotoQualityPrioritization else { return }
-            self.beginConfiguration()
-            defer { self.commitConfiguration() }
+        guard maxPhotoQualityPrioritization != self.maxPhotoQualityPrioritization else { return }
+        sessionQueue.async {
+            self.configurationDepth += 1
+            self.session.beginConfiguration()
+            defer {
+                self.session.commitConfiguration()
+                self.configurationDepth -= 1
+                self.handlePendingStopIfNeeded()
+            }
             self.maxPhotoQualityPrioritization = maxPhotoQualityPrioritization
             self.photoOutput.maxPhotoQualityPrioritization = maxPhotoQualityPrioritization?.avQualityPrioritization ?? .balanced
         }
     }
-
+    
     func update(cameraType: CameraType) {
-        sessionQueue.async { [weak self] in
-            guard let self else { return }
+        sessionQueue.async {
             if self.videoDeviceInput?.device.position == cameraType.avPosition {
                 return
             }
@@ -421,14 +387,19 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                   let videoDeviceInput = try? AVCaptureDeviceInput(device: videoDevice) else {
                 return
             }
-
+            
             self.removeObservers()
-            self.beginConfiguration()
-            defer { self.commitConfiguration() }
+            self.configurationDepth += 1
+            self.session.beginConfiguration()
+            defer {
+                self.session.commitConfiguration()
+                self.configurationDepth -= 1
+                self.handlePendingStopIfNeeded()
+            }
 
             // 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) {
                 self.session.addInput(videoDeviceInput)
                 self.resetZoom(forDevice: videoDevice)
@@ -437,14 +408,14 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                 // If it fails, put back current camera
                 self.session.addInput(currentViewDeviceInput)
             }
-
+            
             self.addObservers()
 
             // We need to reapply the configuration after reloading the camera
             self.update(torchMode: self.torchMode)
         }
     }
-
+    
     func update(resizeMode: ResizeMode) {
         DispatchQueue.main.async {
             switch resizeMode {
@@ -455,7 +426,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-
+    
     func capturePicture(onWillCapture: @escaping () -> Void,
         onSuccess: @escaping (_ imageData: Data, _ thumbnailData: Data?, _ dimensions: CMVideoDimensions) -> Void,
         onError: @escaping (_ message: String) -> Void) {
@@ -464,41 +435,39 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
          entering the session queue. Do this to ensure that UI elements are accessed on
          the main thread and session configuration is done on the session queue.
          */
-
+        
+        // Pause OCR + barcode before capturing
+        self.pauseNonEssentialOutputs()
+        
         DispatchQueue.main.async { [weak self] in
             guard let self = self else {
                 onError("Camera was deallocated")
                 return
             }
-
+            
             let videoPreviewLayerOrientation =
             self.videoOrientation(from: self.deviceOrientation) ?? self.cameraPreview.previewLayer.connection?.videoOrientation
-
+            
             self.sessionQueue.async { [weak self] in
                 guard let self = self else {
                     onError("Camera was deallocated")
                     return
                 }
 
-                guard self.inProgressPhotoCaptureDelegates.isEmpty else {
-                    onError("Capture already in progress")
-                    return
-                }
-
                 // Validate that the session is ready for photo capture
                 guard self.session.isRunning else {
                     print("Cannot capture photo: session is not running")
                     onError("Camera session is not running")
                     return
                 }
-
+                
                 // Ensure photo output has an active video connection
                 guard let photoOutputConnection = self.photoOutput.connection(with: .video) else {
                     print("Cannot capture photo: no video connection available")
                     onError("Camera connection is not available")
                     return
                 }
-
+                
                 // Verify the connection is active and enabled
                 guard photoOutputConnection.isActive && photoOutputConnection.isEnabled else {
                     print("Cannot capture photo: video connection is not active or enabled")
@@ -511,9 +480,6 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                     photoOutputConnection.videoOrientation = videoPreviewLayerOrientation
                 }
 
-                // Pause OCR + barcode work on the session queue, right before capture.
-                self.pauseNonEssentialOutputs()
-
                 let settings = AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.jpeg])
                 if #available(iOS 13.0, *) {
                     settings.photoQualityPrioritization = self.photoOutput.maxPhotoQualityPrioritization
@@ -527,30 +493,32 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                     with: settings,
                     onWillCapture: onWillCapture,
                     onCaptureSuccess: { [weak self] uniqueID, imageData, thumbnailData, dimensions in
-                        self?.sessionQueue.async { self?.inProgressPhotoCaptureDelegates[uniqueID] = nil }
+                        // Use weak self to prevent crash if camera is deallocated during capture
+                        self?.inProgressPhotoCaptureDelegates[uniqueID] = nil
                         onSuccess(imageData, thumbnailData, dimensions)
                         self?.resumeNonEssentialOutputs()
                     },
                     onCaptureError: { [weak self] uniqueID, errorMessage in
-                        self?.sessionQueue.async { self?.inProgressPhotoCaptureDelegates[uniqueID] = nil }
+                        // Use weak self to prevent crash if camera is deallocated during capture
+                        self?.inProgressPhotoCaptureDelegates[uniqueID] = nil
                         onError(errorMessage)
                         self?.resumeNonEssentialOutputs()
                     }
                 )
-
+                
                 self.inProgressPhotoCaptureDelegates[photoCaptureDelegate.requestedPhotoSettings.uniqueID] = photoCaptureDelegate
                 self.photoOutput.capturePhoto(with: settings, delegate: photoCaptureDelegate)
             }
         }
     }
-
+    
     // MARK: - Barcode scanning
     func isBarcodeScannerEnabled(_ isEnabled: Bool,
                                  supportedBarcodeTypes supportedBarcodeType: [CodeFormat],
                                  onBarcodeRead: ((_ barcode: String,_ codeFormat:CodeFormat) -> Void)?) {
         sessionQueue.async {
             self.onBarcodeRead = onBarcodeRead
-
+            
             let availableTypes = self.metadataOutput.availableMetadataObjectTypes
             let newTypes: [AVMetadataObject.ObjectType]
             if isEnabled && onBarcodeRead != nil {
@@ -567,11 +535,11 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-
+    
     func update(barcodeFrameSize: CGSize?) {
         self.barcodeFrameSize = barcodeFrameSize
     }
-
+    
     func update(scannerFrameSize: CGRect?) {
         guard self.scannerFrameSize != scannerFrameSize else { return }
         self.sessionQueue.async {
@@ -579,11 +547,11 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             if !self.session.isRunning {
                 return
             }
-
+            
             DispatchQueue.main.async {
                 var visibleRect: CGRect?
-                if let scannerFrameSize, scannerFrameSize != .zero {
-                    visibleRect = self.cameraPreview.previewLayer.metadataOutputRectConverted(fromLayerRect: scannerFrameSize)
+                if scannerFrameSize != nil && scannerFrameSize != .zero {
+                    visibleRect = self.cameraPreview.previewLayer.metadataOutputRectConverted(fromLayerRect: scannerFrameSize!)
                 }
 
                 self.sessionQueue.async {
@@ -598,7 +566,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-
+    
 
     func isTextDetectionEnabled(_ isEnabled: Bool, onTextRead: ((String) -> Void)?) {
         sessionQueue.async {
@@ -613,26 +581,26 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                 self.textRequest?.recognitionLanguages = ["en", "fr", "de", "es", "vi"]
                 self.textRequest?.recognitionLevel = .accurate
                 self.textRequest?.usesLanguageCorrection = false
-
+                
                 self.videoDataOutput.alwaysDiscardsLateVideoFrames = true
                 self.videoDataOutput.setSampleBufferDelegate(self, queue: globalOCRQueue)
                 self.videoDataOutput.videoSettings = [
                     kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarFullRange
                 ]
-
+                
             } else {
                 self.textRequest = nil
             }
         }
     }
-
+    
     // AVCaptureVideoDataOutputSampleBufferDelegate
     func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
         guard textDetectionEnabled, let request = textRequest else { return }
         let now = Date()
         if now.timeIntervalSince(lastTextProcess) < textThrottle { return }
         lastTextProcess = now
-
+        
         globalOCRQueue.async {
             guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
             var requestOptions: [VNImageOption: Any] = [:]
@@ -645,7 +613,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-
+    
     // MARK: - AVCaptureMetadataOutputObjectsDelegate
 
     func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
@@ -659,7 +627,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
         onBarcodeRead?(codeStringValue,barcodeType)
     }
-
+    
     // MARK: - Private
 
     private func videoOrientation(from deviceOrientation: UIDeviceOrientation) -> AVCaptureVideoOrientation? {
@@ -678,7 +646,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         @unknown default: return nil
         }
     }
-
+    
     private func videoOrientation(from interfaceOrientation: UIInterfaceOrientation) -> AVCaptureVideoOrientation {
         switch interfaceOrientation {
         case .portrait:
@@ -693,14 +661,14 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         @unknown default: return .portrait
         }
     }
-
+    
     private func getBestDevice(for cameraType: CameraType) -> AVCaptureDevice? {
         if let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: cameraType.avPosition) {
             return device // single-lens/physical device
         }
         return nil
     }
-
+    
     private func defaultZoomFactor(for videoDevice: AVCaptureDevice) -> CGFloat {
         let fallback = 1.0
         guard #available(iOS 13.0, *) else { return fallback }
@@ -761,9 +729,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         motionManager = CMMotionManager()
         motionManager?.accelerometerUpdateInterval = 0.2
         motionManager?.gyroUpdateInterval = 0.2
-
-        motionManager?.startAccelerometerUpdates(to: OperationQueue(), withHandler: { [weak self] (accelerometerData, error) -> Void in
-            guard let self else { return }
+        motionManager?.startAccelerometerUpdates(to: OperationQueue(), withHandler: { (accelerometerData, error) -> Void in
             guard error == nil else {
                 print("\(error!)")
                 return
@@ -774,13 +740,12 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
 
             guard let newOrientation = self.deviceOrientation(from: accelerometerData.acceleration),
-                  newOrientation != self.deviceOrientation,
-                  let orientation = Orientation(from: newOrientation) else {
+                  newOrientation != self.deviceOrientation else {
                 return
             }
 
             self.deviceOrientation = newOrientation
-            self.onOrientationChange?(["orientation": orientation.rawValue])
+            self.onOrientationChange?(["orientation": Orientation.init(from: newOrientation)!.rawValue])
         })
 #endif
     }
@@ -805,34 +770,30 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     // MARK: Private observers
 
     private func addObservers() {
-        if adjustingFocusObservation == nil {
-            adjustingFocusObservation = videoDeviceInput?.device.observe(\.isAdjustingFocus,
-                                                                          options: .new,
-                                                                          changeHandler: { [weak self] _, change in
-                guard let self, let isFocusing = change.newValue else { return }
+        guard adjustingFocusObservation == nil else { return }
 
-                self.isAdjustingFocus(isFocusing: isFocusing)
-            })
-        }
+        adjustingFocusObservation = videoDeviceInput?.device.observe(\.isAdjustingFocus,
+                                                                      options: .new,
+                                                                      changeHandler: { [weak self] _, change in
+            guard let self, let isFocusing = change.newValue else { return }
 
-        guard notificationObservers.isEmpty else { return }
+            self.isAdjustingFocus(isFocusing: isFocusing)
+        })
+
+        NotificationCenter.default.addObserver(forName: .AVCaptureDeviceSubjectAreaDidChange,
+                                               object: videoDeviceInput?.device,
+                                               queue: nil,
+                                               using: { [weak self] notification in self?.subjectAreaDidChange(notification: notification) })
+        NotificationCenter.default.addObserver(forName: .AVCaptureSessionRuntimeError,
+                                               object: session,
+                                               queue: nil,
+                                               using: { [weak self] notification in self?.sessionRuntimeError(notification: notification) })
 
-        let subjectAreaToken = NotificationCenter.default.addObserver(
-            forName: .AVCaptureDeviceSubjectAreaDidChange,
-            object: videoDeviceInput?.device,
-            queue: nil,
-            using: { [weak self] notification in self?.subjectAreaDidChange(notification: notification) })
-        let runtimeErrorToken = NotificationCenter.default.addObserver(
-            forName: .AVCaptureSessionRuntimeError,
-            object: session,
-            queue: nil,
-            using: { [weak self] notification in self?.sessionRuntimeError(notification: notification) })
-        notificationObservers = [subjectAreaToken, runtimeErrorToken]
     }
 
     private func removeObservers() {
-        notificationObservers.forEach { NotificationCenter.default.removeObserver($0) }
-        notificationObservers.removeAll()
+        // swiftlint:disable:next notification_center_detachment
+        NotificationCenter.default.removeObserver(self)
 
         adjustingFocusObservation?.invalidate()
         adjustingFocusObservation = nil
@@ -868,99 +829,39 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
         print("Capture session runtime error: \(error)")
 
-        // Automatically try to restart the session if media services were reset.
-        // (After a reset the session is NOT running, so the restart is routed
-        // through the guarded helper, which only starts when it is safe to.)
+        // Automatically try to restart the session running if media services were reset
         if error.code == .mediaServicesWereReset {
-            sessionQueue.async { [weak self] in
-                self?.startSessionIfNeeded()
+            sessionQueue.async {
+                if self.session.isRunning {
+                    self.session.startRunning()
+                }
             }
         }
     }
 
     func startCamera() {
-        sessionQueue.async { [weak self] in
-            self?.startSessionIfNeeded()
+        self.sessionQueue.async {
+            if !self.session.isRunning {
+                self.session.startRunning()
+            }
         }
     }
 
     func stopCamera() {
-        sessionQueue.async { [weak self] in
-            self?.stopSessionIfNeeded()
-        }
-    }
-
-    // MARK: - Session configuration transaction helpers
-
-    /// Debug-only tripwire enforcing the core invariant of this class: EVERY
-    /// AVCaptureSession mutation and start/stop happens on `sessionQueue`. The whole
-    /// "startRunning may not be called between beginConfiguration and
-    /// commitConfiguration" crash class is prevented precisely because nothing
-    /// touches the session off this serial queue. If a future change — or an
-    /// external caller such as a mini-app native bridge — ever reaches one of these
-    /// methods on the wrong queue, this fails loudly in DEBUG/QA instead of
-    /// crashing randomly in production. Compiled out of release builds, so it can
-    /// never add a production crash.
-    private func assertOnSessionQueue() {
-#if DEBUG
-        dispatchPrecondition(condition: .onQueue(sessionQueue))
-#endif
-    }
-
-    /// Opens a session configuration transaction and tracks nesting depth.
-    /// MUST be balanced by `commitConfiguration()` (use `defer`) and MUST run on
-    /// `sessionQueue`.
-    private func beginConfiguration() {
-        assertOnSessionQueue()
-        configurationDepth += 1
-        session.beginConfiguration()
-    }
-
-    /// Closes a session configuration transaction and flushes a stop that was
-    /// requested while the transaction was open. MUST run on `sessionQueue`.
-    private func commitConfiguration() {
-        assertOnSessionQueue()
-        session.commitConfiguration()
-        configurationDepth -= 1
-        handlePendingStopIfNeeded()
-    }
-
-    /// Starts the session only when it is safe to do so. MUST run on `sessionQueue`.
-    /// Because every begin/commit pair is synchronous on the serial session queue,
-    /// `configurationDepth` is always 0 at the start of a fresh queue block — the
-    /// depth check is therefore defence-in-depth against ever calling this from
-    /// inside an open transaction.
-    private func startSessionIfNeeded() {
-        assertOnSessionQueue()
-        guard setupResult == .success,
-              configurationDepth == 0,
-              !pendingStop,
-              !session.isRunning else {
-            return
-        }
-        session.startRunning()
-    }
-
-    /// Stops the session, deferring until the current transaction commits if one
-    /// is open. MUST run on `sessionQueue`.
-    private func stopSessionIfNeeded() {
-        assertOnSessionQueue()
-        guard session.isRunning else { return }
-        if configurationDepth > 0 {
-            pendingStop = true
-            return
+        self.sessionQueue.async {
+            if self.session.isRunning {
+                self.session.stopRunning()
+            }
         }
-        session.stopRunning()
     }
 
     // MARK: - Private helper for safe session stop
-
+    
     private func handlePendingStopIfNeeded() {
         // Must be called on sessionQueue after configuration completes
-        assertOnSessionQueue()
         // Only execute if all configurations are done (depth == 0)
         guard configurationDepth == 0 && pendingStop else { return }
-
+        
         pendingStop = false
         if session.isRunning {
             session.stopRunning()

package/package.json

@@ -1,41 +1,41 @@
 {
-  "name": "@momo-kits/camerakit",
-  "version": "0.161.2-beta.2",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/teslamotors/react-native-camera-kit.git"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
-  },
-  "description": "A high performance, fully featured, rock solid camera library for React Native applications",
-  "nativePackage": true,
-  "scripts": {
-    "build": "echo",
-    "test": "jest",
-    "lint": "yarn eslint -c .eslintrc.js"
-  },
-  "main": "./src/index.ts",
-  "dependencies": {},
-  "license": "MIT",
-  "devDependencies": {
-    "react": "19.0.0",
-    "react-native": "0.80.1"
-  },
-  "peerDependencies": {
-    "react": "*",
-    "react-native": "*"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "codegenConfig": {
-    "name": "rncamerakit_specs",
-    "type": "all",
-    "jsSrcsDir": "src/specs",
-    "android": {
-      "javaPackageName": "com.rncamerakit"
-    }
-  },
-  "packageManager": "yarn@1.22.22"
-}
+    "name": "@momo-kits/camerakit",
+    "version": "0.161.2-beta.7",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/teslamotors/react-native-camera-kit.git"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "description": "A high performance, fully featured, rock solid camera library for React Native applications",
+    "nativePackage": true,
+    "scripts": {
+        "build": "echo",
+        "test": "jest",
+        "lint": "yarn eslint -c .eslintrc.js"
+    },
+    "main": "./src/index.ts",
+    "dependencies": {},
+    "license": "MIT",
+    "devDependencies": {
+        "react": "19.0.0",
+        "react-native": "0.80.1"
+    },
+    "peerDependencies": {
+        "react": "*",
+        "react-native": "*"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "codegenConfig": {
+        "name": "rncamerakit_specs",
+        "type": "all",
+        "jsSrcsDir": "src/specs",
+        "android": {
+            "javaPackageName": "com.rncamerakit"
+        }
+    },
+    "packageManager": "yarn@1.22.22"
+}