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

package/ios/BarcodeDetectionManager.swift

@@ -0,0 +1,229 @@
+//
+//  BarcodeDetectionManager.swift
+//  react-native-scanner
+//
+//  Manages barcode detection using Vision framework
+//
+
+import Foundation
+import Vision
+import AVFoundation
+
+/// Manages barcode detection using Vision framework
+class BarcodeDetectionManager: NSObject, BarcodeScannerProtocol {
+    
+    // MARK: - Public Properties
+    
+    /// Delegate for detection events
+    weak var delegate: BarcodeDetectionDelegate?
+    
+    // MARK: - Private Properties
+    
+    /// Supported barcode symbologies
+    private var supportedSymbologies: [VNBarcodeSymbology]
+    
+    /// Scan strategy
+    private var scanStrategy: BarcodeScanStrategy
+    
+    /// Whether scanning is paused
+    private var scanningPaused: Bool
+    
+    /// Background queue for detection
+    private let detectionQueue: DispatchQueue
+    
+    // MARK: - Initialization
+    
+    override init() {
+        // Default: all supported formats
+        self.supportedSymbologies = [
+            .qr, .code128, .code39, .ean13, .ean8,
+            .upce, .pdf417, .aztec, .dataMatrix, .itf14
+        ]
+        self.scanStrategy = .defaultStrategy
+        self.scanningPaused = false
+        self.detectionQueue = DispatchQueue(label: "com.scanner.detection")
+        
+        super.init()
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Detect barcodes in a sample buffer
+    /// - Parameter sampleBuffer: The sample buffer to analyze
+    func detectBarcodes(in sampleBuffer: CMSampleBuffer) {
+        guard !scanningPaused else { return }
+        
+        guard let pixelBuffer = getPixelBuffer(from: sampleBuffer) else {
+            return
+        }
+        
+        let request = createDetectionRequest()
+        let orientation = getImageOrientation(from: sampleBuffer)
+        
+        let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer,
+                                           orientation: orientation,
+                                           options: [:])
+        
+        detectionQueue.async { [weak self] in
+            do {
+                try handler.perform([request])
+            } catch {
+                print("[BarcodeDetectionManager] Detection failed: \(error)")
+                DispatchQueue.main.async {
+                    self?.delegate?.barcodeDetectionManager(self!, didFailWith: error)
+                }
+            }
+        }
+    }
+    
+    /// Detect barcodes in a CMSampleBuffer with completion
+    /// - Parameters:
+    ///   - sampleBuffer: The sample buffer to analyze
+    ///   - completion: Completion handler with observations
+    func detectBarcodes(in sampleBuffer: CMSampleBuffer,
+                       completion: @escaping ([VNBarcodeObservation]) -> Void) {
+        guard !scanningPaused else {
+            completion([])
+            return
+        }
+        
+        guard let pixelBuffer = getPixelBuffer(from: sampleBuffer) else {
+            completion([])
+            return
+        }
+        
+        let request = VNDetectBarcodesRequest { request, error in
+            if let error = error {
+                print("[BarcodeDetectionManager] Detection error: \(error)")
+                completion([])
+                return
+            }
+            
+            guard let results = request.results as? [VNBarcodeObservation] else {
+                completion([])
+                return
+            }
+            
+            completion(results)
+        }
+        
+        request.symbologies = supportedSymbologies
+        
+        let orientation = getImageOrientation(from: sampleBuffer)
+        let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer,
+                                           orientation: orientation,
+                                           options: [:])
+        
+        detectionQueue.async {
+            do {
+                try handler.perform([request])
+            } catch {
+                print("[BarcodeDetectionManager] Detection failed: \(error)")
+                completion([])
+            }
+        }
+    }
+    
+    // MARK: - BarcodeScannerProtocol Methods
+    
+    /// Pause barcode scanning
+    func pauseScanning() {
+        scanningPaused = true
+        print("[BarcodeDetectionManager] Scanning paused")
+    }
+    
+    /// Resume barcode scanning
+    func resumeScanning() {
+        scanningPaused = false
+        print("[BarcodeDetectionManager] Scanning resumed")
+    }
+    
+    /// Check if scanning is paused
+    /// - Returns: True if scanning is paused
+    func isScanningPaused() -> Bool {
+        // Implementation: Return paused state
+        return scanningPaused
+    }
+    
+    /// Set the barcode formats to detect
+    /// - Parameter formats: Array of barcode formats
+    func setBarcodeFormats(_ formats: [BarcodeFormat]) {
+        if formats.isEmpty {
+            // If empty, use all supported formats
+            supportedSymbologies = [
+                .qr, .code128, .code39, .ean13, .ean8,
+                .upce, .pdf417, .aztec, .dataMatrix, .itf14
+            ]
+        } else {
+            supportedSymbologies = formats.map { $0.visionSymbology }
+        }
+        print("[BarcodeDetectionManager] Barcode formats updated: \(supportedSymbologies)")
+    }
+    
+    /// Set the scan strategy
+    /// - Parameter strategy: The scan strategy to use
+    func setScanStrategy(_ strategy: BarcodeScanStrategy) {
+        scanStrategy = strategy
+        print("[BarcodeDetectionManager] Scan strategy set to: \(strategy.rawValue)")
+    }
+    
+    // MARK: - Private Methods
+    
+    /// Create a barcode detection request
+    /// - Returns: Configured VNDetectBarcodesRequest
+    private func createDetectionRequest() -> VNDetectBarcodesRequest {
+        let request = VNDetectBarcodesRequest { [weak self] request, error in
+            self?.handleDetectionResults(request: request, error: error)
+        }
+        
+        request.symbologies = supportedSymbologies
+        
+        return request
+    }
+    
+    /// Process detection results
+    /// - Parameters:
+    ///   - request: The completed request
+    ///   - error: Any error that occurred
+    private func handleDetectionResults(request: VNRequest, error: Error?) {
+        if let error = error {
+            print("[BarcodeDetectionManager] Detection error: \(error)")
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self else { return }
+                self.delegate?.barcodeDetectionManager(self, didFailWith: error)
+            }
+            return
+        }
+        
+        guard let results = request.results as? [VNBarcodeObservation] else {
+            return
+        }
+        
+        // Filter out barcodes without valid payload
+        let validBarcodes = results.filter { $0.payloadStringValue != nil }
+        
+        if !validBarcodes.isEmpty {
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self else { return }
+                self.delegate?.barcodeDetectionManager(self, didDetect: validBarcodes)
+            }
+        }
+    }
+    
+    /// Get pixel buffer from sample buffer
+    /// - Parameter sampleBuffer: The sample buffer
+    /// - Returns: Pixel buffer or nil
+    private func getPixelBuffer(from sampleBuffer: CMSampleBuffer) -> CVPixelBuffer? {
+        return CMSampleBufferGetImageBuffer(sampleBuffer)
+    }
+    
+    /// Get image orientation from sample buffer
+    /// - Parameter sampleBuffer: The sample buffer
+    /// - Returns: CGImagePropertyOrientation
+    private func getImageOrientation(from sampleBuffer: CMSampleBuffer) -> CGImagePropertyOrientation {
+        // For most cases, .up works well
+        // In production, you might want to account for device orientation
+        return .up
+    }
+}
+

package/ios/BarcodeFrameManager.swift

@@ -0,0 +1,175 @@
+//
+//  BarcodeFrameManager.swift
+//  react-native-scanner
+//
+//  Manages barcode frame lifecycle with timeout
+//
+
+import Foundation
+import CoreGraphics
+
+/// Manages barcode frames with automatic timeout and cleanup
+class BarcodeFrameManager {
+    
+    // MARK: - Public Properties
+    
+    /// Delegate for frame change notifications
+    weak var delegate: BarcodeFrameManagerDelegate?
+    
+    /// Callback for frame changes
+    var onFramesChanged: (([CGRect]) -> Void)?
+    
+    // MARK: - Private Properties
+    
+    /// Active barcode frames mapped by barcode data
+    private var activeFrames: [String: BarcodeFrame] = [:]
+    
+    /// Timeout duration for frames (seconds)
+    private let frameTimeout: TimeInterval
+    
+    /// Timer for cleanup
+    private var cleanupTimer: Timer?
+    
+    /// Queue for thread-safe access
+    private let queue: DispatchQueue
+    
+    // MARK: - Initialization
+    
+    init(frameTimeout: TimeInterval = 1.0) {
+        self.frameTimeout = frameTimeout
+        self.queue = DispatchQueue(label: "com.scanner.framemanager", attributes: .concurrent)
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Update barcode frames with new detections
+    /// - Parameter frames: Dictionary mapping barcode data to rectangles
+    func updateBarcodeFrames(_ frames: [String: CGRect]) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            
+            let now = Date()
+            let currentKeys = Set(frames.keys)
+            
+            // Update or add frames with current timestamp
+            for (key, rect) in frames {
+                self.activeFrames[key] = BarcodeFrame(rect: rect, lastSeenTime: now)
+            }
+            
+            // Remove frames not in current detection
+            self.activeFrames = self.activeFrames.filter { currentKeys.contains($0.key) }
+            
+            // Schedule cleanup if we have frames
+            if !self.activeFrames.isEmpty {
+                DispatchQueue.main.async {
+                    self.scheduleCleanup()
+                }
+            }
+            
+            // Notify observers
+            self.notifyFramesChanged()
+        }
+    }
+    
+    /// Get current active frames for display
+    /// - Returns: Array of active frame rectangles
+    func getActiveFrames() -> [CGRect] {
+        return queue.sync {
+            return activeFrames.values.map { $0.rect }
+        }
+    }
+    
+    /// Clear all barcode frames immediately
+    func clearAllFrames() {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            
+            let hadFrames = !self.activeFrames.isEmpty
+            self.activeFrames.removeAll()
+            
+            DispatchQueue.main.async {
+                self.cleanupTimer?.invalidate()
+                self.cleanupTimer = nil
+                
+                if hadFrames {
+                    self.notifyFramesChanged()
+                }
+            }
+        }
+    }
+    
+    /// Shutdown the manager and cleanup resources
+    func shutdown() {
+        clearAllFrames()
+        print("[BarcodeFrameManager] Shutdown")
+    }
+    
+    // MARK: - Private Methods
+    
+    /// Schedule cleanup of stale frames
+    private func scheduleCleanup() {
+        // Cancel existing timer
+        cleanupTimer?.invalidate()
+        
+        // Schedule new timer
+        cleanupTimer = Timer.scheduledTimer(
+            timeInterval: frameTimeout,
+            target: self,
+            selector: #selector(cleanupStaleFrames),
+            userInfo: nil,
+            repeats: false
+        )
+    }
+    
+    /// Clean up stale frames
+    @objc private func cleanupStaleFrames() {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            
+            let now = Date()
+            let countBefore = self.activeFrames.count
+            
+            // Remove frames older than timeout
+            self.activeFrames = self.activeFrames.filter { _, frame in
+                now.timeIntervalSince(frame.lastSeenTime) < self.frameTimeout
+            }
+            
+            let framesRemoved = countBefore - self.activeFrames.count
+            
+            if framesRemoved > 0 {
+                print("[BarcodeFrameManager] Removed \(framesRemoved) stale frame(s)")
+                self.notifyFramesChanged()
+            }
+            
+            // Reschedule if frames remain
+            if !self.activeFrames.isEmpty {
+                DispatchQueue.main.async {
+                    self.scheduleCleanup()
+                }
+            } else {
+                print("[BarcodeFrameManager] No more frames to monitor")
+            }
+        }
+    }
+    
+    /// Notify observers of frame changes
+    private func notifyFramesChanged() {
+        let currentFrames = activeFrames.values.map { $0.rect }
+        
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            // Call delegate
+            self.delegate?.barcodeFrameManager(self, didUpdateFrames: currentFrames)
+            
+            // Call callback
+            self.onFramesChanged?(currentFrames)
+        }
+    }
+    
+    deinit {
+        // Implementation: Cleanup timer
+        cleanupTimer?.invalidate()
+    }
+}
+

package/ios/BarcodeFrameOverlayView.swift

@@ -0,0 +1,102 @@
+//
+//  BarcodeFrameOverlayView.swift
+//  react-native-scanner
+//
+//  Overlay view for barcode frame visualization
+//
+
+import UIKit
+
+/// View that draws rectangles around detected barcodes
+class BarcodeFrameOverlayView: UIView, BarcodeFrameDisplayProtocol {
+    
+    // MARK: - Public Properties
+    
+    /// Color for barcode frame borders
+    var frameColor: UIColor = .yellow {
+        didSet { setNeedsDisplay() }
+    }
+    
+    /// Width of the frame stroke
+    var frameStrokeWidth: CGFloat = 3.0 {
+        didSet { setNeedsDisplay() }
+    }
+    
+    // MARK: - Private Properties
+    
+    /// Array of barcode rectangles to draw
+    private var barcodeBoxes: [CGRect] = [] {
+        didSet { setNeedsDisplay() }
+    }
+    
+    // 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
+    }
+    
+    // MARK: - Drawing
+    
+    override func draw(_ rect: CGRect) {
+        super.draw(rect)
+        
+        guard let context = UIGraphicsGetCurrentContext() else { return }
+        
+        // Implementation: Draw rectangles for each barcode
+        drawBarcodeFrames(in: context)
+    }
+    
+    /// Draw barcode frame rectangles
+    /// - Parameter context: Graphics context
+    private func drawBarcodeFrames(in context: CGContext) {
+        guard !barcodeBoxes.isEmpty else { return }
+        
+        // Set stroke color and width
+        context.setStrokeColor(frameColor.cgColor)
+        context.setLineWidth(frameStrokeWidth)
+        context.setLineCap(.round)
+        context.setLineJoin(.round)
+        
+        // Draw rectangle for each barcode box
+        for box in barcodeBoxes {
+            context.stroke(box)
+        }
+    }
+    
+    // MARK: - BarcodeFrameDisplayProtocol Methods
+    
+    /// Update the barcode frames configuration
+    /// - Parameter config: The new configuration
+    func updateBarcodeFrames(config: BarcodeFramesConfig) {
+        frameColor = config.color
+        setNeedsDisplay()
+    }
+    
+    /// Set the barcode boxes to display
+    /// - Parameter boxes: Array of rectangles to display
+    func setBarcodeBoxes(_ boxes: [CGRect]) {
+        // Implementation: Update boxes on main thread
+        DispatchQueue.main.async { [weak self] in
+            self?.barcodeBoxes = boxes
+        }
+    }
+    
+    /// Clear all barcode boxes
+    func clearBarcodeBoxes() {
+        // Implementation: Clear boxes array
+        setBarcodeBoxes([])
+    }
+}
+