@momo-kits/camerakit 0.161.1-beta.1 → 0.161.2-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,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/RealCamera.swift

@@ -71,16 +71,22 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     // 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()
             }
         }
@@ -96,117 +102,96 @@ 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]) {
-        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()
+
+                self.update(torchMode: self.torchMode)
+            }
 
-            // 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 }
+            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
+        
+        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
+        
+        if session.canAddInput(videoDeviceInput) {
+            session.addInput(videoDeviceInput)
+            self.videoDeviceInput = videoDeviceInput
+            self.resetZoom(forDevice: videoDevice)
+            return .success
         }
-
-        // 3. Photo output
+        return .sessionConfigurationFailed
+    }
+    
+    private func setupAdditionalOutputs(supportedBarcodeType: [CodeFormat]) {
+        configurationDepth += 1
+        session.beginConfiguration()
+        defer {
+            session.commitConfiguration()
+            configurationDepth -= 1
+            handlePendingStopIfNeeded()
+        }
+        
+        // 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() }
@@ -214,49 +199,29 @@ 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)
         }
     }
     
@@ -396,18 +361,21 @@ class RealCamera: NSObject, CameraProtocol, AVCaptureMetadataOutputObjectsDelega
     func update(maxPhotoQualityPrioritization: MaxPhotoQualityPrioritization?) {
         guard #available(iOS 13.0, *) else { return }
         guard maxPhotoQualityPrioritization != self.maxPhotoQualityPrioritization else { return }
-        sessionQueue.async { [weak self] in
-            guard let self else { return }
-            self.beginConfiguration()
-            defer { self.commitConfiguration() }
+        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
             }
@@ -419,10 +387,15 @@ 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)
@@ -463,6 +436,9 @@ 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")
@@ -504,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
@@ -856,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.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"
-}
+    "name": "@momo-kits/camerakit",
+    "version": "0.161.2-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"
+}