@momo-kits/camerakit 0.160.1-beta.8 → 0.161.1-beta.1

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;
 }
 
@@ -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/RealCamera.swift

@@ -71,22 +71,16 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     // 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()
             }
         }
@@ -102,96 +96,117 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     
     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]) {
-        
-        // 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()
-
-                self.update(torchMode: self.torchMode)
-            }
+        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
+
+        beginConfiguration()
+        defer { commitConfiguration() }
+
+        // 1. Video input
+        guard session.canAddInput(videoDeviceInput) else {
+            return .sessionConfigurationFailed
         }
-        return .sessionConfigurationFailed
-    }
-    
-    private func setupAdditionalOutputs(supportedBarcodeType: [CodeFormat]) {
-        configurationDepth += 1
-        session.beginConfiguration()
-        defer {
-            session.commitConfiguration()
-            configurationDepth -= 1
-            handlePendingStopIfNeeded()
+        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,29 +214,49 @@ 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
+                }
+            }
         }
     }
     
@@ -361,21 +396,18 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     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 }
+            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,15 +419,10 @@ 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)
@@ -436,9 +463,6 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
          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")
@@ -480,6 +504,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
@@ -829,39 +856,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,41 +1,41 @@
 {
-    "name": "@momo-kits/camerakit",
-    "version": "0.160.1-beta.8",
-    "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.1-beta.1",
+  "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"
+}