@momo-kits/camerakit 0.161.2-beta.5 → 0.161.2-beta.8

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 = [focusMode isEqualToString:@"on"] ? CKZoomModeOn : CKZoomModeOff;
+        _view.zoomMode = [zoomMode 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,6 +260,12 @@ 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,12 +18,8 @@ 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 (firstFeature.messageString != nil ) {
-                self.onBarcodeRead(barcode: firstFeature.messageString!, codeFormat: CodeFormat.qr)
+            if let messageString = firstFeature.messageString {
+                self.onBarcodeRead(barcode: 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()
-    // Communicate with the session and other session objects on this queue.
-    private let sessionQueue = DispatchQueue(label: "com.tesla.react-native-camera-kit")
-    
+    private static let sharedSessionQueue = DispatchQueue(label: "com.tesla.react-native-camera-kit.session")
+    private let sessionQueue = RealCamera.sharedSessionQueue
+
     // 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,44 +49,40 @@ 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 {
-            if self.setupResult == .success {
-                // Only stop if session is running
-                guard self.session.isRunning else {
-                    self.removeObservers()
-                    return
-                }
+        sessionQueue.async { [weak self] in
+            guard let self, self.setupResult == .success else { return }
 
-                // 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
-                }
+            // Stop now if idle/safe, or defer the stop until the open configuration
+            // transaction commits (stopSessionIfNeeded sets pendingStop in that case).
+            self.stopSessionIfNeeded()
 
-                self.session.stopRunning()
+            // If the stop was deferred, handlePendingStopIfNeeded() will remove the
+            // observers once the transaction commits; otherwise remove them now.
+            if !self.pendingStop {
                 self.removeObservers()
             }
         }
@@ -99,99 +95,120 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         UIDevice.current.endGeneratingDeviceOrientationNotifications()
 #endif
     }
-    
+
     deinit {
         removeObservers()
-    }
-    
-    // MARK: - Public
 
-    func setup(cameraType: CameraType, supportedBarcodeType: [CodeFormat]) {
-        
-        // Setup the capture session with priority on basic video preview first
+        // 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 {
-            self.setupResult = self.setupBasicVideoInput(cameraType: cameraType)
-
-            if self.setupResult == .success {
-                self.session.startRunning()
-
-                self.setupAdditionalOutputs(supportedBarcodeType: supportedBarcodeType)
+            if session.isRunning {
+                session.stopRunning()
+            }
+        }
+    }
 
-                self.addObservers()
+    // MARK: - Public
 
-                self.update(torchMode: self.torchMode)
-            }
+    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)
 
-            DispatchQueue.main.async {
+            // 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.cameraPreview.session = self.session
                 self.cameraPreview.previewLayer.videoGravity = .resizeAspectFill
-                self.session.sessionPreset = .photo
                 self.setVideoOrientationToInterfaceOrientation()
             }
         }
-        
-        DispatchQueue.global(qos: .utility).async {
-            self.initializeMotionManager()
-        }
 
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            self?.initializeMotionManager()
+        }
     }
 
     // MARK: - Private optimization methods
-    
-    private func setupBasicVideoInput(cameraType: CameraType) -> SetupResult {
+
+    /// 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()
         guard let videoDevice = self.getBestDevice(for: cameraType),
               let videoDeviceInput = try? AVCaptureDeviceInput(device: videoDevice) else {
             return .sessionConfigurationFailed
         }
-        
-        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()
+
+        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
         }
-        
-        // Add photo output
+
+        // 3. Photo output
         if #available(iOS 13.0, *) {
             if let maxPhotoQualityPrioritization = maxPhotoQualityPrioritization {
                 photoOutput.maxPhotoQualityPrioritization = maxPhotoQualityPrioritization.avQualityPrioritization
             }
         }
-        
         if session.canAddOutput(photoOutput) {
             session.addOutput(photoOutput)
-
-            if let photoOutputConnection = self.photoOutput.connection(with: .video) {
-                if photoOutputConnection.isVideoStabilizationSupported {
-                    photoOutputConnection.preferredVideoStabilizationMode = .auto
-                }
+            // Connection only exists after the output is added to the session.
+            if let photoOutputConnection = self.photoOutput.connection(with: .video),
+               photoOutputConnection.isVideoStabilizationSupported {
+                photoOutputConnection.preferredVideoStabilizationMode = .auto
             }
         }
-        
-        // Add metadata output for barcode scanning
+
+        // 4. 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() }
@@ -199,39 +216,59 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
             metadataOutput.metadataObjectTypes = filteredTypes
         }
-        
-        // add for text detections
-        if (textRequest != nil && self.session.canAddOutput(self.videoDataOutput)) {
+
+        // 5. Video data output for text / MRZ detection
+        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() {
-        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)
+        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
+                }
+            }
         }
     }
-    
+
     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 }
 
@@ -240,7 +277,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
@@ -251,14 +288,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
@@ -269,7 +306,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
      */
@@ -290,11 +327,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)
@@ -309,7 +346,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                     self.resetFocus = nil
                     self.focusFinished = nil
                 }
-                
+
                 do {
                     try videoDevice.lockForConfiguration()
 
@@ -332,11 +369,11 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-    
+
     func update(onOrientationChange: RCTDirectEventBlock?) {
         self.onOrientationChange = onOrientationChange
     }
-    
+
     func update(torchMode: TorchMode) {
         sessionQueue.async {
             self.torchMode = torchMode
@@ -353,29 +390,26 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-    
+
     func update(flashMode: FlashMode) {
         self.flashMode = flashMode
     }
-    
+
     func update(maxPhotoQualityPrioritization: MaxPhotoQualityPrioritization?) {
         guard #available(iOS 13.0, *) else { return }
-        guard maxPhotoQualityPrioritization != self.maxPhotoQualityPrioritization else { return }
-        sessionQueue.async {
-            self.configurationDepth += 1
-            self.session.beginConfiguration()
-            defer {
-                self.session.commitConfiguration()
-                self.configurationDepth -= 1
-                self.handlePendingStopIfNeeded()
-            }
+        sessionQueue.async { [weak self] in
+            guard let self else { return }
+            guard maxPhotoQualityPrioritization != self.maxPhotoQualityPrioritization else { return }
+            self.beginConfiguration()
+            defer { self.commitConfiguration() }
             self.maxPhotoQualityPrioritization = maxPhotoQualityPrioritization
             self.photoOutput.maxPhotoQualityPrioritization = maxPhotoQualityPrioritization?.avQualityPrioritization ?? .balanced
         }
     }
-    
+
     func update(cameraType: CameraType) {
-        sessionQueue.async {
+        sessionQueue.async { [weak self] in
+            guard let self else { return }
             if self.videoDeviceInput?.device.position == cameraType.avPosition {
                 return
             }
@@ -387,19 +421,14 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                   let videoDeviceInput = try? AVCaptureDeviceInput(device: videoDevice) else {
                 return
             }
-            
+
             self.removeObservers()
-            self.configurationDepth += 1
-            self.session.beginConfiguration()
-            defer {
-                self.session.commitConfiguration()
-                self.configurationDepth -= 1
-                self.handlePendingStopIfNeeded()
-            }
+            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) {
                 self.session.addInput(videoDeviceInput)
                 self.resetZoom(forDevice: videoDevice)
@@ -408,14 +437,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 {
@@ -426,7 +455,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) {
@@ -435,39 +464,41 @@ 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")
@@ -480,6 +511,9 @@ 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
@@ -493,32 +527,30 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
                     with: settings,
                     onWillCapture: onWillCapture,
                     onCaptureSuccess: { [weak self] uniqueID, imageData, thumbnailData, dimensions in
-                        // Use weak self to prevent crash if camera is deallocated during capture
-                        self?.inProgressPhotoCaptureDelegates[uniqueID] = nil
+                        self?.sessionQueue.async { self?.inProgressPhotoCaptureDelegates[uniqueID] = nil }
                         onSuccess(imageData, thumbnailData, dimensions)
                         self?.resumeNonEssentialOutputs()
                     },
                     onCaptureError: { [weak self] uniqueID, errorMessage in
-                        // Use weak self to prevent crash if camera is deallocated during capture
-                        self?.inProgressPhotoCaptureDelegates[uniqueID] = nil
+                        self?.sessionQueue.async { 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 {
@@ -535,11 +567,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 {
@@ -547,11 +579,11 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             if !self.session.isRunning {
                 return
             }
-            
+
             DispatchQueue.main.async {
                 var visibleRect: CGRect?
-                if scannerFrameSize != nil && scannerFrameSize != .zero {
-                    visibleRect = self.cameraPreview.previewLayer.metadataOutputRectConverted(fromLayerRect: scannerFrameSize!)
+                if let scannerFrameSize, scannerFrameSize != .zero {
+                    visibleRect = self.cameraPreview.previewLayer.metadataOutputRectConverted(fromLayerRect: scannerFrameSize)
                 }
 
                 self.sessionQueue.async {
@@ -566,7 +598,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-    
+
 
     func isTextDetectionEnabled(_ isEnabled: Bool, onTextRead: ((String) -> Void)?) {
         sessionQueue.async {
@@ -581,26 +613,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] = [:]
@@ -613,7 +645,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
         }
     }
-    
+
     // MARK: - AVCaptureMetadataOutputObjectsDelegate
 
     func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
@@ -627,7 +659,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
         onBarcodeRead?(codeStringValue,barcodeType)
     }
-    
+
     // MARK: - Private
 
     private func videoOrientation(from deviceOrientation: UIDeviceOrientation) -> AVCaptureVideoOrientation? {
@@ -646,7 +678,7 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         @unknown default: return nil
         }
     }
-    
+
     private func videoOrientation(from interfaceOrientation: UIInterfaceOrientation) -> AVCaptureVideoOrientation {
         switch interfaceOrientation {
         case .portrait:
@@ -661,14 +693,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 }
@@ -729,7 +761,9 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
         motionManager = CMMotionManager()
         motionManager?.accelerometerUpdateInterval = 0.2
         motionManager?.gyroUpdateInterval = 0.2
-        motionManager?.startAccelerometerUpdates(to: OperationQueue(), withHandler: { (accelerometerData, error) -> Void in
+
+        motionManager?.startAccelerometerUpdates(to: OperationQueue(), withHandler: { [weak self] (accelerometerData, error) -> Void in
+            guard let self else { return }
             guard error == nil else {
                 print("\(error!)")
                 return
@@ -740,12 +774,13 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
             }
 
             guard let newOrientation = self.deviceOrientation(from: accelerometerData.acceleration),
-                  newOrientation != self.deviceOrientation else {
+                  newOrientation != self.deviceOrientation,
+                  let orientation = Orientation(from: newOrientation) else {
                 return
             }
 
             self.deviceOrientation = newOrientation
-            self.onOrientationChange?(["orientation": Orientation.init(from: newOrientation)!.rawValue])
+            self.onOrientationChange?(["orientation": orientation.rawValue])
         })
 #endif
     }
@@ -770,30 +805,34 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     // MARK: Private observers
 
     private func addObservers() {
-        guard adjustingFocusObservation == nil else { return }
+        if adjustingFocusObservation == nil {
+            adjustingFocusObservation = videoDeviceInput?.device.observe(\.isAdjustingFocus,
+                                                                          options: .new,
+                                                                          changeHandler: { [weak self] _, change in
+                guard let self, let isFocusing = change.newValue else { return }
 
-        adjustingFocusObservation = videoDeviceInput?.device.observe(\.isAdjustingFocus,
-                                                                      options: .new,
-                                                                      changeHandler: { [weak self] _, change in
-            guard let self, let isFocusing = change.newValue else { return }
-
-            self.isAdjustingFocus(isFocusing: isFocusing)
-        })
+                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) })
+        guard notificationObservers.isEmpty else { return }
 
+        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() {
-        // swiftlint:disable:next notification_center_detachment
-        NotificationCenter.default.removeObserver(self)
+        notificationObservers.forEach { NotificationCenter.default.removeObserver($0) }
+        notificationObservers.removeAll()
 
         adjustingFocusObservation?.invalidate()
         adjustingFocusObservation = nil
@@ -829,39 +868,99 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
 
         print("Capture session runtime error: \(error)")
 
-        // Automatically try to restart the session running if media services were reset
+        // 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.)
         if error.code == .mediaServicesWereReset {
-            sessionQueue.async {
-                if self.session.isRunning {
-                    self.session.startRunning()
-                }
+            sessionQueue.async { [weak self] in
+                self?.startSessionIfNeeded()
             }
         }
     }
 
     func startCamera() {
-        self.sessionQueue.async {
-            if !self.session.isRunning {
-                self.session.startRunning()
-            }
+        sessionQueue.async { [weak self] in
+            self?.startSessionIfNeeded()
         }
     }
 
     func stopCamera() {
-        self.sessionQueue.async {
-            if self.session.isRunning {
-                self.session.stopRunning()
-            }
+        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
         }
+        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,6 +1,6 @@
 {
     "name": "@momo-kits/camerakit",
-    "version": "0.161.2-beta.5",
+    "version": "0.161.2-beta.8",
     "repository": {
         "type": "git",
         "url": "https://github.com/teslamotors/react-native-camera-kit.git"