@cleanuidev/react-native-scanner 1.0.0-beta.1

package/ios/CameraManager.swift

@@ -0,0 +1,396 @@
+//
+//  CameraManager.swift
+//  react-native-scanner
+//
+//  Manages AVFoundation camera operations
+//
+
+import AVFoundation
+import UIKit
+
+/// Manages camera session, input, and output
+class CameraManager: NSObject, CameraControlProtocol {
+    
+    // MARK: - Public Properties
+    
+    /// Delegate for camera events
+    weak var delegate: CameraManagerDelegate?
+    
+    /// The preview layer for displaying camera feed
+    private(set) var previewLayer: AVCaptureVideoPreviewLayer?
+    
+    // MARK: - Private Properties
+    
+    /// Main capture session
+    private let captureSession: AVCaptureSession
+    
+    /// Background queue for camera operations
+    private let sessionQueue: DispatchQueue
+    
+    /// Video data output for frame capture
+    private var videoDataOutput: AVCaptureVideoDataOutput?
+    
+    /// Current camera device
+    private var currentDevice: AVCaptureDevice?
+    
+    /// Current camera input
+    private var currentInput: AVCaptureDeviceInput?
+    
+    /// Whether the session is running
+    private var isSessionRunning: Bool
+
+    /// Whether the session has been configured at least once
+    private var isSessionConfigured: Bool = false
+
+    // Desired settings (can be set before camera is configured/running)
+    private var desiredTorchEnabled: Bool = false
+    private var desiredTorchLevel: Float = 1.0
+    private var desiredZoomLevel: CGFloat = 1.0
+    
+    // MARK: - Initialization
+    
+    override init() {
+        self.captureSession = AVCaptureSession()
+        self.sessionQueue = DispatchQueue(label: "com.scanner.camera.session")
+        self.isSessionRunning = false
+        
+        super.init()
+    }
+    
+    // MARK: - CameraControlProtocol Methods
+    
+    /// Start the camera session
+    func startCamera() {
+        checkCameraPermission { [weak self] granted in
+            guard let self = self, granted else {
+                let error = NSError(domain: "CameraManager", code: 1,
+                                  userInfo: [NSLocalizedDescriptionKey: "Camera permission denied"])
+                DispatchQueue.main.async {
+                    self?.delegate?.cameraManagerDidFail(self!, error: error)
+                }
+                return
+            }
+            
+            self.sessionQueue.async {
+                if !self.isSessionConfigured {
+                    self.configureCaptureSession()
+                    self.isSessionConfigured = true
+                }
+                if !self.captureSession.isRunning {
+                    self.captureSession.startRunning()
+                    self.isSessionRunning = true
+                }
+
+                // Apply any desired settings now that the session/device exists
+                self.applyZoom()
+                self.applyTorch()
+                
+                DispatchQueue.main.async {
+                    self.delegate?.cameraManagerDidStart(self)
+                }
+            }
+        }
+    }
+    
+    /// Stop the camera session
+    func stopCamera() {
+        sessionQueue.async { [weak self] in
+            guard let self = self, self.isSessionRunning else { return }
+            
+            // Always turn torch off when stopping camera to avoid leaving hardware active.
+            self.forceTorchOff()
+
+            if self.captureSession.isRunning {
+                self.captureSession.stopRunning()
+            }
+            self.isSessionRunning = false
+        }
+    }
+    
+    /// Set torch/flashlight state
+    /// - Parameter enabled: Whether torch should be enabled
+    func setTorch(enabled: Bool) {
+        desiredTorchEnabled = enabled
+        print("[CameraManager] Torch requested: \(enabled)")
+        sessionQueue.async { [weak self] in
+            self?.applyTorch()
+        }
+    }
+    
+    /// Set zoom level
+    /// - Parameter level: The zoom level (clamped to device limits)
+    func setZoom(level: CGFloat) {
+        desiredZoomLevel = level
+        sessionQueue.async { [weak self] in
+            self?.applyZoom()
+        }
+    }
+    
+    /// Check if torch is available
+    /// - Returns: True if torch is available
+    func isTorchAvailable() -> Bool {
+        return currentDevice?.hasTorch ?? false
+    }
+    
+    /// Get the preview layer for displaying camera feed
+    /// - Returns: The AVCaptureVideoPreviewLayer
+    func getPreviewLayer() -> AVCaptureVideoPreviewLayer? {
+        // Implementation: Return preview layer
+        return previewLayer
+    }
+    
+    // MARK: - Private Setup Methods
+    
+    /// Configure the capture session
+    private func configureCaptureSession() {
+        captureSession.beginConfiguration()
+        captureSession.sessionPreset = .high
+        
+        // Setup camera input
+        guard setupCameraInput() else {
+            captureSession.commitConfiguration()
+            return
+        }
+        
+        // Setup video output
+        guard setupVideoOutput() else {
+            captureSession.commitConfiguration()
+            return
+        }
+        
+        captureSession.commitConfiguration()
+
+        // Apply desired settings once input/output are configured
+        applyZoom()
+        applyTorch()
+        
+        // Setup preview layer on main thread
+        DispatchQueue.main.async { [weak self] in
+            self?.setupPreviewLayer()
+        }
+    }
+    
+    /// Setup camera input
+    /// - Returns: True if setup successful
+    @discardableResult
+    private func setupCameraInput() -> Bool {
+        guard let device = getDefaultCameraDevice() else {
+            print("[CameraManager] No camera device available")
+            return false
+        }
+        
+        do {
+            let input = try AVCaptureDeviceInput(device: device)
+            
+            if captureSession.canAddInput(input) {
+                captureSession.addInput(input)
+                currentDevice = device
+                currentInput = input
+                print("[CameraManager] Camera input added successfully")
+                return true
+            } else {
+                print("[CameraManager] Cannot add camera input to session")
+                return false
+            }
+        } catch {
+            print("[CameraManager] Error creating camera input: \(error)")
+            return false
+        }
+    }
+
+    // MARK: - Apply desired settings
+
+    private func applyTorch() {
+        guard let device = currentDevice else {
+            print("[CameraManager] ⚠️ applyTorch: no currentDevice yet")
+            return
+        }
+        guard device.hasTorch else {
+            print("[CameraManager] ⚠️ applyTorch: device hasTorch=false (\(device.localizedName))")
+            return
+        }
+
+        print("[CameraManager] applyTorch -> desired=\(desiredTorchEnabled) device=\(device.localizedName) position=\(device.position.rawValue) currentMode=\(device.torchMode.rawValue) active=\(device.isTorchActive)")
+
+        lockDeviceForConfiguration(device) { device in
+            if self.desiredTorchEnabled {
+                if device.isTorchModeSupported(.on) {
+                    do {
+                        try device.setTorchModeOn(level: self.desiredTorchLevel)
+                        print("[CameraManager] ✅ Torch ON applied via setTorchModeOn(level:) on \(device.localizedName)")
+                    } catch {
+                        // Fallback
+                        device.torchMode = .on
+                        print("[CameraManager] ⚠️ Torch ON fallback (setTorchModeOn failed: \(error.localizedDescription))")
+                    }
+                } else {
+                    device.torchMode = .on
+                    print("[CameraManager] ⚠️ Torch ON fallback (mode .on not supported??) on \(device.localizedName)")
+                }
+            } else {
+                if device.isTorchModeSupported(.off) {
+                    device.torchMode = .off
+                    print("[CameraManager] ✅ Torch OFF applied on \(device.localizedName)")
+                } else {
+                    device.torchMode = .off
+                    print("[CameraManager] ⚠️ Torch OFF fallback (mode .off not supported??) on \(device.localizedName)")
+                }
+            }
+        }
+
+        print("[CameraManager] applyTorch done -> mode=\(device.torchMode.rawValue) active=\(device.isTorchActive)")
+    }
+
+    private func forceTorchOff() {
+        guard let device = currentDevice, device.hasTorch else { return }
+        lockDeviceForConfiguration(device) { device in
+            if device.isTorchModeSupported(.off) {
+                device.torchMode = .off
+            } else {
+                device.torchMode = .off
+            }
+        }
+    }
+
+    private func applyZoom() {
+        guard let device = currentDevice else { return }
+        lockDeviceForConfiguration(device) { device in
+            let clampedZoom = min(max(self.desiredZoomLevel, device.minAvailableVideoZoomFactor),
+                                  device.maxAvailableVideoZoomFactor)
+            device.videoZoomFactor = clampedZoom
+        }
+    }
+    
+    /// Setup video output
+    /// - Returns: True if setup successful
+    @discardableResult
+    private func setupVideoOutput() -> Bool {
+        let output = AVCaptureVideoDataOutput()
+        output.setSampleBufferDelegate(self, queue: sessionQueue)
+        output.videoSettings = [
+            kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA
+        ]
+        output.alwaysDiscardsLateVideoFrames = true
+        
+        if captureSession.canAddOutput(output) {
+            captureSession.addOutput(output)
+            videoDataOutput = output
+            print("[CameraManager] Video output added successfully")
+            return true
+        } else {
+            print("[CameraManager] Cannot add video output to session")
+            return false
+        }
+    }
+    
+    /// Setup preview layer
+    private func setupPreviewLayer() {
+        let preview = AVCaptureVideoPreviewLayer(session: captureSession)
+        preview.videoGravity = .resizeAspectFill
+        previewLayer = preview
+        print("[CameraManager] Preview layer created")
+    }
+    
+    // MARK: - Camera Configuration
+    
+    /// Get the default camera device (back camera)
+    /// - Returns: The camera device or nil
+    private func getDefaultCameraDevice() -> AVCaptureDevice? {
+        // Prefer a BACK camera that supports torch.
+        let deviceTypes: [AVCaptureDevice.DeviceType] = [
+            .builtInTripleCamera,
+            .builtInDualCamera,
+            .builtInDualWideCamera,
+            .builtInWideAngleCamera,
+            .builtInTelephotoCamera,
+            .builtInUltraWideCamera,
+        ]
+
+        let discovery = AVCaptureDevice.DiscoverySession(
+            deviceTypes: deviceTypes,
+            mediaType: .video,
+            position: .back
+        )
+
+        if let torchBack = discovery.devices.first(where: { $0.hasTorch }) {
+            print("[CameraManager] ✅ Using back camera with torch: \(torchBack.localizedName)")
+            return torchBack
+        }
+
+        if let anyBack = discovery.devices.first {
+            print("[CameraManager] ⚠️ Back camera found but hasTorch=false: \(anyBack.localizedName)")
+            return anyBack
+        }
+
+        // Fallback to any available video device
+        print("[CameraManager] ⚠️ No back camera available, using default(for: .video)")
+        if let device = AVCaptureDevice.default(for: .video) {
+            print("[CameraManager] Default camera position: \(device.position.rawValue) - \(device.localizedName) (hasTorch=\(device.hasTorch))")
+            return device
+        }
+
+        print("[CameraManager] ❌ No camera device available!")
+        return nil
+    }
+    
+    /// Check camera permissions
+    /// - Parameter completion: Callback with permission status
+    private func checkCameraPermission(completion: @escaping (Bool) -> Void) {
+        switch AVCaptureDevice.authorizationStatus(for: .video) {
+        case .authorized:
+            completion(true)
+            
+        case .notDetermined:
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                completion(granted)
+            }
+            
+        case .denied, .restricted:
+            print("[CameraManager] Camera permission denied or restricted")
+            completion(false)
+            
+        @unknown default:
+            completion(false)
+        }
+    }
+    
+    // MARK: - Helper Methods
+    
+    /// Lock device for configuration
+    /// - Parameter device: The device to lock
+    /// - Parameter configurator: Configuration block
+    private func lockDeviceForConfiguration(_ device: AVCaptureDevice,
+                                           configurator: (AVCaptureDevice) -> Void) {
+        do {
+            try device.lockForConfiguration()
+            configurator(device)
+            device.unlockForConfiguration()
+        } catch {
+            print("[CameraManager] Failed to lock device for configuration: \(error)")
+        }
+    }
+    
+    deinit {
+        stopCamera()
+        print("[CameraManager] Deinitialized")
+    }
+}
+
+// MARK: - AVCaptureVideoDataOutputSampleBufferDelegate
+
+extension CameraManager: AVCaptureVideoDataOutputSampleBufferDelegate {
+    func captureOutput(_ output: AVCaptureOutput,
+                      didOutput sampleBuffer: CMSampleBuffer,
+                      from connection: AVCaptureConnection) {
+        // Forward sample buffer to delegate for processing
+        delegate?.cameraManager(self, didOutput: sampleBuffer)
+    }
+    
+    func captureOutput(_ output: AVCaptureOutput,
+                      didDrop sampleBuffer: CMSampleBuffer,
+                      from connection: AVCaptureConnection) {
+        // Optionally log dropped frames for debugging
+        // print("[CameraManager] Dropped frame")
+    }
+}
+

package/ios/CoordinateTransformer.swift

@@ -0,0 +1,140 @@
+//
+//  CoordinateTransformer.swift
+//  react-native-scanner
+//
+//  Transforms coordinates between Vision and View coordinate spaces
+//
+
+import Foundation
+import CoreGraphics
+import AVFoundation
+
+/// Utility for transforming coordinates between different spaces
+class CoordinateTransformer: CoordinateTransformationProtocol {
+    
+    // MARK: - Public Static Methods
+    
+    /// Transform Vision framework coordinates to view coordinates
+    /// - Parameters:
+    ///   - visionRect: Rectangle in Vision coordinate space (normalized 0-1, bottom-left origin)
+    ///   - viewSize: The size of the view
+    ///   - previewLayer: The preview layer for additional transformation
+    /// - Returns: Rectangle in view coordinate space (points, top-left origin)
+    static func transformVisionRectToViewRect(_ visionRect: CGRect,
+                                             viewSize: CGSize,
+                                             previewLayer: AVCaptureVideoPreviewLayer?) -> CGRect {
+        // Best-effort: when we have a previewLayer, use Apple's conversion.
+        // Vision boundingBox is normalized (0-1) with origin at bottom-left.
+        // AVCapture metadata normalized rect expects origin at top-left.
+        if let layer = previewLayer {
+            let metadataRect = CGRect(
+                x: visionRect.minX,
+                y: 1.0 - visionRect.minY - visionRect.height,
+                width: visionRect.width,
+                height: visionRect.height
+            )
+            return layer.layerRectConverted(fromMetadataOutputRect: metadataRect)
+        }
+
+        // Fallback (no previewLayer): approximate in view coords.
+        // Step 1: Denormalize from 0-1 to view size
+        var rect = denormalizeRect(visionRect, toSize: viewSize)
+        // Step 2: Flip Y-axis (Vision uses bottom-left, UIKit uses top-left)
+        rect = flipYAxis(rect, containerHeight: viewSize.height)
+        return rect
+    }
+    
+    /// Transform view coordinates to Vision framework coordinates
+    /// - Parameters:
+    ///   - viewRect: Rectangle in view coordinate space (points, top-left origin)
+    ///   - viewSize: The size of the view
+    ///   - previewLayer: The preview layer for additional transformation
+    /// - Returns: Rectangle in Vision coordinate space (normalized 0-1, bottom-left origin)
+    static func transformViewRectToVisionRect(_ viewRect: CGRect,
+                                             viewSize: CGSize,
+                                             previewLayer: AVCaptureVideoPreviewLayer?) -> CGRect {
+        var rect = viewRect
+        
+        // Step 1: Account for video gravity if provided (reverse)
+        if let _ = previewLayer {
+            // Note: This is simplified; full implementation would reverse the video gravity transformation
+            rect = viewRect
+        }
+        
+        // Step 2: Flip Y-axis (UIKit to Vision)
+        rect = flipYAxis(rect, containerHeight: viewSize.height)
+        
+        // Step 3: Normalize from view size to 0-1
+        rect = normalizeRect(rect, fromSize: viewSize)
+        
+        return rect
+    }
+    
+    // MARK: - Private Helper Methods
+    
+    /// Flip rectangle's Y-axis
+    /// - Parameters:
+    ///   - rect: Rectangle to flip
+    ///   - containerHeight: Height of the container
+    /// - Returns: Flipped rectangle
+    private static func flipYAxis(_ rect: CGRect, containerHeight: CGFloat) -> CGRect {
+        // Implementation: Flip from bottom-left to top-left origin or vice versa
+        return CGRect(
+            x: rect.minX,
+            y: containerHeight - rect.maxY,
+            width: rect.width,
+            height: rect.height
+        )
+    }
+    
+    /// Denormalize rectangle from 0-1 to actual size
+    /// - Parameters:
+    ///   - normalizedRect: Normalized rectangle (0-1)
+    ///   - size: Target size
+    /// - Returns: Denormalized rectangle
+    private static func denormalizeRect(_ normalizedRect: CGRect, toSize size: CGSize) -> CGRect {
+        // Implementation: Scale from normalized to actual coordinates
+        return CGRect(
+            x: normalizedRect.minX * size.width,
+            y: normalizedRect.minY * size.height,
+            width: normalizedRect.width * size.width,
+            height: normalizedRect.height * size.height
+        )
+    }
+    
+    /// Normalize rectangle from actual size to 0-1
+    /// - Parameters:
+    ///   - rect: Rectangle in actual coordinates
+    ///   - size: Source size
+    /// - Returns: Normalized rectangle (0-1)
+    private static func normalizeRect(_ rect: CGRect, fromSize size: CGSize) -> CGRect {
+        guard size.width > 0 && size.height > 0 else { return .zero }
+        
+        return CGRect(
+            x: rect.minX / size.width,
+            y: rect.minY / size.height,
+            width: rect.width / size.width,
+            height: rect.height / size.height
+        )
+    }
+    
+    /// Account for preview layer's video gravity transformation
+    /// - Parameters:
+    ///   - rect: Rectangle to transform
+    ///   - previewLayer: The preview layer
+    /// - Returns: Transformed rectangle
+    private static func accountForVideoGravity(_ rect: CGRect,
+                                              previewLayer: AVCaptureVideoPreviewLayer) -> CGRect {
+        // Use the preview layer's built-in transformation if available
+        // This accounts for ResizeAspectFill, ResizeAspect, etc.
+        
+        // For most cases with ResizeAspectFill, the rect is already correct
+        // because we're working in the same coordinate space as the view
+        
+        // Advanced: Could use layerRectConverted(fromMetadataOutputRect:)
+        // but that's for metadata coordinates, not Vision coordinates
+        
+        return rect
+    }
+}
+

package/ios/FocusAreaOverlayView.swift

@@ -0,0 +1,161 @@
+//
+//  FocusAreaOverlayView.swift
+//  react-native-scanner
+//
+//  Overlay view for focus area visualization
+//
+
+import UIKit
+
+/// View that draws the focus area overlay with semi-transparent tint and clear center
+class FocusAreaOverlayView: UIView, FocusAreaProtocol {
+    
+    // MARK: - Public Properties
+    
+    /// Whether the overlay is visible
+    var isOverlayVisible: Bool = false {
+        didSet { setNeedsDisplay() }
+    }
+    
+    /// Border color for the focus area
+    var borderColor: UIColor = .clear {
+        didSet { setNeedsDisplay() }
+    }
+    
+    /// Tint color for the overlay (semi-transparent).
+    /// Use a custom property name to avoid clashing with UIView.tintColor.
+    var overlayTintColor: UIColor = UIColor.black.withAlphaComponent(0.5) {
+        didSet { setNeedsDisplay() }
+    }
+    
+    /// Size of the focus area frame
+    var frameSize: CGSize = CGSize(width: 300, height: 300) {
+        didSet { setNeedsDisplay() }
+    }
+    
+    /// Position of the focus area (percentage 0-100)
+    var position: CGPoint = CGPoint(x: 50, y: 50) {
+        didSet { setNeedsDisplay() }
+    }
+    
+    /// The calculated frame rectangle in view coordinates
+    private(set) var frameRect: CGRect = .zero
+
+    // MARK: - Layers (more reliable than draw/blend modes)
+
+    private let overlayLayer = CAShapeLayer()
+    private let borderLayer = CAShapeLayer()
+    
+    // MARK: - Initialization
+    
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupView()
+    }
+    
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupView()
+    }
+    
+    private func setupView() {
+        // Implementation: Configure view properties
+        backgroundColor = .clear
+        isUserInteractionEnabled = false
+        isOpaque = false
+
+        overlayLayer.fillRule = .evenOdd
+        overlayLayer.fillColor = overlayTintColor.cgColor
+        overlayLayer.isHidden = true
+        layer.addSublayer(overlayLayer)
+
+        borderLayer.fillColor = UIColor.clear.cgColor
+        borderLayer.strokeColor = borderColor.cgColor
+        borderLayer.lineWidth = 4.0
+        borderLayer.isHidden = true
+        layer.addSublayer(borderLayer)
+    }
+    
+    // MARK: - Layer Updates
+
+    private func updateLayers() {
+        frameRect = calculateFrameRect()
+
+        // Overlay cutout path (even-odd fill)
+        let path = UIBezierPath(rect: bounds)
+        path.append(UIBezierPath(rect: frameRect))
+
+        overlayLayer.frame = bounds
+        overlayLayer.path = path.cgPath
+        overlayLayer.fillColor = overlayTintColor.cgColor
+        overlayLayer.isHidden = !isOverlayVisible
+
+        // Border path
+        borderLayer.frame = bounds
+        borderLayer.path = UIBezierPath(rect: frameRect).cgPath
+        borderLayer.strokeColor = borderColor.cgColor
+        borderLayer.isHidden = (!isOverlayVisible) || (borderColor == .clear)
+    }
+    
+    /// Calculate the focus area frame rectangle
+    /// - Returns: The calculated frame rectangle
+    private func calculateFrameRect() -> CGRect {
+        // Calculate center position based on percentage
+        let centerX = bounds.width * (position.x / 100.0)
+        let centerY = bounds.height * (position.y / 100.0)
+        
+        // Create rectangle centered at calculated position
+        let rect = CGRect(
+            x: centerX - frameSize.width / 2,
+            y: centerY - frameSize.height / 2,
+            width: frameSize.width,
+            height: frameSize.height
+        )
+        
+        return rect
+    }
+    
+    // MARK: - Layout
+    
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        updateLayers()
+    }
+    
+    // MARK: - FocusAreaProtocol Methods
+    
+    /// Update focus area configuration
+    /// - Parameter config: The new configuration
+    func updateFocusArea(config: FocusAreaConfig) {
+        isOverlayVisible = config.showOverlay
+        borderColor = config.borderColor
+        overlayTintColor = config.tintColor
+        frameSize = config.size.size
+        position = config.position
+
+        updateLayers()
+    }
+    
+    /// Get the current focus area frame in view coordinates
+    /// - Returns: The focus area rectangle
+    func getFocusAreaFrame() -> CGRect? {
+        // Return the frame rect regardless of overlay visibility.
+        // Overlay visibility controls drawing; filtering should depend on FocusAreaConfig.enabled.
+        return frameRect.isEmpty ? nil : frameRect
+    }
+    
+    /// Check if a point is within the focus area
+    /// - Parameter point: The point to check
+    /// - Returns: True if the point is within the focus area
+    func isPointInFocusArea(_ point: CGPoint) -> Bool {
+        return frameRect.contains(point)
+    }
+    
+    /// Check if a rectangle intersects or is contained in the focus area
+    /// - Parameter rect: The rectangle to check
+    /// - Returns: True if the rectangle intersects or is contained
+    func isRectInFocusArea(_ rect: CGRect) -> Bool {
+        // Match Android behavior: require barcode box to be fully inside the focus frame.
+        return frameRect.contains(rect)
+    }
+}