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

package/ios/Models.swift

@@ -0,0 +1,341 @@
+//
+//  Models.swift
+//  react-native-scanner
+//
+//  Created for iOS barcode scanner implementation
+//
+
+import Foundation
+import UIKit
+import Vision
+
+// MARK: - Barcode Format Enum
+
+/// Supported barcode formats, mapped from React Native props
+enum BarcodeFormat: String {
+    case qrCode = "QR_CODE"
+    case code128 = "CODE_128"
+    case code39 = "CODE_39"
+    case ean13 = "EAN_13"
+    case ean8 = "EAN_8"
+    case upcA = "UPC_A"
+    case upcE = "UPC_E"
+    case dataMatrix = "DATA_MATRIX"
+    case pdf417 = "PDF_417"
+    case aztec = "AZTEC"
+    case itf = "ITF"
+    
+    /// Convert to Vision framework symbology
+    var visionSymbology: VNBarcodeSymbology {
+        switch self {
+        case .qrCode: return .qr
+        case .code128: return .code128
+        case .code39: return .code39
+        case .ean13: return .ean13
+        case .ean8: return .ean8
+        case .upcA: return .upce  // Note: UPCA is handled as UPCE in Vision
+        case .upcE: return .upce
+        case .dataMatrix: return .dataMatrix
+        case .pdf417: return .pdf417
+        case .aztec: return .aztec
+        case .itf: return .itf14
+        }
+    }
+    
+    /// Get all supported formats
+    static var allFormats: [BarcodeFormat] {
+        return [.qrCode, .code128, .code39, .ean13, .ean8, .upcA, .upcE, .dataMatrix, .pdf417, .aztec, .itf]
+    }
+}
+
+// MARK: - Barcode Scan Strategy
+
+/// Strategy for processing multiple detected barcodes
+enum BarcodeScanStrategy: String {
+    case one = "ONE"                    // Process only the first barcode
+    case all = "ALL"                    // Process all detected barcodes
+    case biggest = "BIGGEST"            // Process only the largest barcode by area
+    case sortByBiggest = "SORT_BY_BIGGEST"  // Process all barcodes sorted by size
+    
+    static var defaultStrategy: BarcodeScanStrategy { .all }
+}
+
+// MARK: - Frame Size
+
+/// Size configuration for focus area frame
+enum FrameSize {
+    case square(size: CGFloat)
+    case rectangle(width: CGFloat, height: CGFloat)
+    
+    /// Get the CGSize representation
+    var size: CGSize {
+        switch self {
+        case .square(let size):
+            return CGSize(width: size, height: size)
+        case .rectangle(let width, let height):
+            return CGSize(width: width, height: height)
+        }
+    }
+    
+    /// Create from React Native prop (number or object)
+    static func from(value: Any) -> FrameSize {
+        if let number = value as? NSNumber {
+            return .square(size: CGFloat(number.doubleValue))
+        } else if let dict = value as? [String: Any],
+                  let width = dict["width"] as? NSNumber,
+                  let height = dict["height"] as? NSNumber {
+            return .rectangle(width: CGFloat(width.doubleValue), height: CGFloat(height.doubleValue))
+        }
+        return .square(size: 300) // Default
+    }
+}
+
+// MARK: - Focus Area Configuration
+
+/// Configuration for the focus area overlay
+struct FocusAreaConfig {
+    var enabled: Bool               // Whether to restrict scanning to focus area only
+    var showOverlay: Bool           // Whether to draw the focus area overlay
+    var size: FrameSize            // Size of the focus area
+    var borderColor: UIColor       // Color of the focus area border
+    var tintColor: UIColor         // Color of the semi-transparent overlay
+    var position: CGPoint          // Position as percentage (0-100)
+    
+    /// Default configuration
+    static var defaultConfig: FocusAreaConfig {
+        return FocusAreaConfig(
+            enabled: false,
+            showOverlay: false,
+            size: .square(size: 300),
+            borderColor: .clear,
+            tintColor: UIColor.black.withAlphaComponent(0.5),
+            position: CGPoint(x: 50, y: 50)
+        )
+    }
+    
+    /// Create from React Native prop dictionary
+    static func from(dict: [String: Any]) -> FocusAreaConfig {
+        var config = defaultConfig
+        
+        if let enabled = dict["enabled"] as? Bool {
+            config.enabled = enabled
+        }
+        
+        if let showOverlay = dict["showOverlay"] as? Bool {
+            config.showOverlay = showOverlay
+        }
+        
+        if let sizeValue = dict["size"] {
+            config.size = FrameSize.from(value: sizeValue)
+        }
+        
+        if let borderColorStr = dict["borderColor"] as? String {
+            config.borderColor = UIColor(hexString: borderColorStr)
+        }
+        
+        if let tintColorStr = dict["tintColor"] as? String {
+            // Match Android behavior: tintColor is treated as a base color with 50% opacity
+            // unless the user explicitly supplies an 8-digit ARGB value.
+            let trimmed = tintColorStr.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
+            let parsed = UIColor(hexString: tintColorStr)
+            if trimmed.count == 8 {
+                // ARGB includes alpha; respect it.
+                config.tintColor = parsed
+            } else {
+                // Force semi-transparent overlay like Android (alpha ~ 0.5)
+                config.tintColor = parsed.withAlphaComponent(0.5)
+            }
+        }
+        
+        if let positionDict = dict["position"] as? [String: Any],
+           let x = positionDict["x"] as? NSNumber,
+           let y = positionDict["y"] as? NSNumber {
+            config.position = CGPoint(x: CGFloat(x.doubleValue), y: CGFloat(y.doubleValue))
+        }
+        
+        return config
+    }
+}
+
+// MARK: - Barcode Frames Configuration
+
+/// Configuration for barcode frame visualization
+struct BarcodeFramesConfig {
+    var enabled: Bool               // Whether to draw frames around detected barcodes
+    var color: UIColor             // Color of barcode frames
+    var onlyInFocusArea: Bool      // Only show frames for barcodes in focus area
+    
+    /// Default configuration
+    static var defaultConfig: BarcodeFramesConfig {
+        return BarcodeFramesConfig(
+            enabled: false,
+            color: .yellow,
+            onlyInFocusArea: false
+        )
+    }
+    
+    /// Create from React Native prop dictionary
+    static func from(dict: [String: Any]) -> BarcodeFramesConfig {
+        var config = defaultConfig
+        
+        if let enabled = dict["enabled"] as? Bool {
+            config.enabled = enabled
+        }
+        
+        if let colorStr = dict["color"] as? String {
+            config.color = UIColor(hexString: colorStr)
+        }
+        
+        if let onlyInFocusArea = dict["onlyInFocusArea"] as? Bool {
+            config.onlyInFocusArea = onlyInFocusArea
+        }
+        
+        return config
+    }
+}
+
+// MARK: - Barcode Detection Result
+
+/// Detected barcode information
+struct BarcodeDetectionResult {
+    let data: String                    // The scanned barcode data
+    let format: String                  // The format of the barcode
+    let timestamp: TimeInterval        // Timestamp when scanned (milliseconds)
+    let boundingBox: CGRect?           // Bounding box in view coordinates
+    let area: CGFloat?                 // Area of the barcode
+    
+    /// Convert to dictionary for React Native event
+    func toDictionary() -> [String: Any] {
+        var dict: [String: Any] = [
+            "data": data,
+            "format": format,
+            "timestamp": timestamp
+        ]
+        
+        if let box = boundingBox {
+            dict["boundingBox"] = [
+                "left": box.minX,
+                "top": box.minY,
+                "right": box.maxX,
+                "bottom": box.maxY
+            ]
+        }
+        
+        if let area = area {
+            dict["area"] = area
+        }
+        
+        return dict
+    }
+    
+    /// Create from Vision barcode observation
+    static func from(observation: VNBarcodeObservation, 
+                    boundingBox: CGRect? = nil,
+                    format: String? = nil) -> BarcodeDetectionResult? {
+        guard let payloadString = observation.payloadStringValue else { return nil }
+        
+        let detectedFormat = format ?? observation.symbology.rawValue
+        let timestamp = Date().timeIntervalSince1970 * 1000 // Convert to milliseconds
+        
+        let area = boundingBox.map { $0.width * $0.height }
+        
+        return BarcodeDetectionResult(
+            data: payloadString,
+            format: detectedFormat,
+            timestamp: timestamp,
+            boundingBox: boundingBox,
+            area: area
+        )
+    }
+}
+
+// MARK: - Barcode Frame Data
+
+/// Data for a single barcode frame
+struct BarcodeFrame {
+    let rect: CGRect
+    var lastSeenTime: Date
+    
+    init(rect: CGRect, lastSeenTime: Date = Date()) {
+        self.rect = rect
+        self.lastSeenTime = lastSeenTime
+    }
+}
+
+// MARK: - Scanner Error
+
+/// Error information for scanner errors
+struct ScannerError {
+    let error: String
+    let code: String
+    
+    /// Convert to dictionary for React Native event
+    func toDictionary() -> [String: Any] {
+        return [
+            "error": error,
+            "code": code
+        ]
+    }
+    
+    /// Common error codes
+    enum ErrorCode: String {
+        case cameraPermissionDenied = "CAMERA_PERMISSION_DENIED"
+        case cameraInitializationFailed = "CAMERA_INITIALIZATION_FAILED"
+        case cameraNotAvailable = "CAMERA_NOT_AVAILABLE"
+        case barcodeDetectionFailed = "BARCODE_DETECTION_FAILED"
+        case unknown = "UNKNOWN_ERROR"
+    }
+    
+    /// Create from error code
+    static func from(code: ErrorCode, message: String) -> ScannerError {
+        return ScannerError(error: message, code: code.rawValue)
+    }
+}
+
+// MARK: - Load Event
+
+/// Load event payload
+struct LoadEventPayload {
+    let success: Bool
+    let error: String?
+    
+    /// Convert to dictionary for React Native event
+    func toDictionary() -> [String: Any] {
+        var dict: [String: Any] = ["success": success]
+        if let error = error {
+            dict["error"] = error
+        }
+        return dict
+    }
+}
+
+// MARK: - UIColor Extension
+
+extension UIColor {
+    /// Create UIColor from hex string
+    convenience init(hexString: String) {
+        let hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
+        var int: UInt64 = 0
+        Scanner(string: hex).scanHexInt64(&int)
+        
+        let a, r, g, b: UInt64
+        switch hex.count {
+        case 3: // RGB (12-bit)
+            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
+        case 6: // RGB (24-bit)
+            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
+        case 8: // ARGB (32-bit)
+            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
+        default:
+            (a, r, g, b) = (255, 0, 0, 0)
+        }
+        
+        self.init(
+            red: CGFloat(r) / 255,
+            green: CGFloat(g) / 255,
+            blue: CGFloat(b) / 255,
+            alpha: CGFloat(a) / 255
+        )
+    }
+}
+

package/ios/Protocols.swift

@@ -0,0 +1,194 @@
+//
+//  Protocols.swift
+//  react-native-scanner
+//
+//  Protocol definitions for scanner components
+//
+
+import Foundation
+import AVFoundation
+import Vision
+
+// MARK: - Scanner View Delegate
+
+/// Delegate protocol for scanner events to be sent to React Native
+@objc protocol ScannerViewDelegate: AnyObject {
+    /// Called when barcodes are detected
+    /// - Parameter barcodes: Array of detected barcode dictionaries
+    func scannerDidDetectBarcodes(_ barcodes: [[String: Any]])
+    
+    /// Called when an error occurs
+    /// - Parameter error: Error information dictionary
+    func scannerDidEncounterError(_ error: [String: Any])
+    
+    /// Called when the scanner is loaded and ready
+    /// - Parameter info: Load information dictionary
+    func scannerDidLoad(_ info: [String: Any])
+}
+
+// MARK: - Camera Manager Delegate
+
+/// Delegate protocol for camera events
+protocol CameraManagerDelegate: AnyObject {
+    /// Called when a new video frame is captured
+    /// - Parameters:
+    ///   - manager: The camera manager
+    ///   - sampleBuffer: The captured sample buffer
+    func cameraManager(_ manager: CameraManager, didOutput sampleBuffer: CMSampleBuffer)
+    
+    /// Called when camera initialization fails
+    /// - Parameters:
+    ///   - manager: The camera manager
+    ///   - error: The error that occurred
+    func cameraManagerDidFail(_ manager: CameraManager, error: Error)
+    
+    /// Called when camera successfully starts
+    /// - Parameter manager: The camera manager
+    func cameraManagerDidStart(_ manager: CameraManager)
+}
+
+// MARK: - Barcode Detection Delegate
+
+/// Delegate protocol for barcode detection events
+protocol BarcodeDetectionDelegate: AnyObject {
+    /// Called when barcodes are detected in a frame
+    /// - Parameters:
+    ///   - manager: The detection manager
+    ///   - observations: Array of barcode observations
+    func barcodeDetectionManager(_ manager: BarcodeDetectionManager, 
+                                 didDetect observations: [VNBarcodeObservation])
+    
+    /// Called when barcode detection fails
+    /// - Parameters:
+    ///   - manager: The detection manager
+    ///   - error: The error that occurred
+    func barcodeDetectionManager(_ manager: BarcodeDetectionManager, 
+                                 didFailWith error: Error)
+}
+
+// MARK: - Barcode Frame Manager Delegate
+
+/// Delegate protocol for barcode frame changes
+protocol BarcodeFrameManagerDelegate: AnyObject {
+    /// Called when the active barcode frames change
+    /// - Parameters:
+    ///   - manager: The frame manager
+    ///   - frames: Array of active frame rectangles
+    func barcodeFrameManager(_ manager: BarcodeFrameManager, 
+                            didUpdateFrames frames: [CGRect])
+}
+
+// MARK: - Camera Control Protocol
+
+/// Protocol for camera control operations
+protocol CameraControlProtocol {
+    /// Start the camera session
+    func startCamera()
+    
+    /// Stop the camera session
+    func stopCamera()
+    
+    /// Set torch/flashlight state
+    /// - Parameter enabled: Whether torch should be enabled
+    func setTorch(enabled: Bool)
+    
+    /// Set zoom level
+    /// - Parameter level: The zoom level (clamped to device limits)
+    func setZoom(level: CGFloat)
+    
+    /// Check if torch is available
+    /// - Returns: True if torch is available
+    func isTorchAvailable() -> Bool
+    
+    /// Get the preview layer for displaying camera feed
+    /// - Returns: The AVCaptureVideoPreviewLayer
+    func getPreviewLayer() -> AVCaptureVideoPreviewLayer?
+}
+
+// MARK: - Barcode Scanner Protocol
+
+/// Protocol for barcode scanning operations
+protocol BarcodeScannerProtocol {
+    /// Pause barcode scanning
+    func pauseScanning()
+    
+    /// Resume barcode scanning
+    func resumeScanning()
+    
+    /// Check if scanning is paused
+    /// - Returns: True if scanning is paused
+    func isScanningPaused() -> Bool
+    
+    /// Set the barcode formats to detect
+    /// - Parameter formats: Array of barcode formats
+    func setBarcodeFormats(_ formats: [BarcodeFormat])
+    
+    /// Set the scan strategy
+    /// - Parameter strategy: The scan strategy to use
+    func setScanStrategy(_ strategy: BarcodeScanStrategy)
+}
+
+// MARK: - Focus Area Protocol
+
+/// Protocol for focus area operations
+protocol FocusAreaProtocol {
+    /// Update focus area configuration
+    /// - Parameter config: The new configuration
+    func updateFocusArea(config: FocusAreaConfig)
+    
+    /// Get the current focus area frame in view coordinates
+    /// - Returns: The focus area rectangle
+    func getFocusAreaFrame() -> CGRect?
+    
+    /// 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
+    
+    /// 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
+}
+
+// MARK: - Barcode Frame Display Protocol
+
+/// Protocol for displaying barcode frames
+protocol BarcodeFrameDisplayProtocol {
+    /// Update the barcode frames configuration
+    /// - Parameter config: The new configuration
+    func updateBarcodeFrames(config: BarcodeFramesConfig)
+    
+    /// Set the barcode boxes to display
+    /// - Parameter boxes: Array of rectangles to display
+    func setBarcodeBoxes(_ boxes: [CGRect])
+    
+    /// Clear all barcode boxes
+    func clearBarcodeBoxes()
+}
+
+// MARK: - Coordinate Transformation Protocol
+
+/// Protocol for coordinate transformation operations
+protocol CoordinateTransformationProtocol {
+    /// Transform Vision framework coordinates to view coordinates
+    /// - Parameters:
+    ///   - visionRect: Rectangle in Vision coordinate space (normalized, bottom-left origin)
+    ///   - viewSize: The size of the view
+    ///   - previewLayer: The preview layer for additional transformation
+    /// - Returns: Rectangle in view coordinate space
+    static func transformVisionRectToViewRect(_ visionRect: CGRect,
+                                             viewSize: CGSize,
+                                             previewLayer: AVCaptureVideoPreviewLayer?) -> CGRect
+    
+    /// Transform view coordinates to Vision framework coordinates
+    /// - Parameters:
+    ///   - viewRect: Rectangle in view coordinate space
+    ///   - viewSize: The size of the view
+    ///   - previewLayer: The preview layer for additional transformation
+    /// - Returns: Rectangle in Vision coordinate space
+    static func transformViewRectToVisionRect(_ viewRect: CGRect,
+                                             viewSize: CGSize,
+                                             previewLayer: AVCaptureVideoPreviewLayer?) -> CGRect
+}
+

package/ios/ScannerView.h

@@ -0,0 +1,14 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#ifndef ScannerViewNativeComponent_h
+#define ScannerViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ScannerView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* ScannerViewNativeComponent_h */