@scr2em/capacitor-scanner 6.0.23 → 6.0.26

package/ios/Sources/CapacitorScannerPlugin/CapacitorScannerPlugin.swift

@@ -1,8 +1,7 @@
 import AVFoundation
 import Capacitor
-import CoreMotion
 import Foundation
-import Vision // For barcode detection
+import Vision
 
 /**
  * Please read the Capacitor iOS Plugin Development Guide
@@ -14,7 +13,7 @@ struct VoteStatus {
 }
 
 @objc(CapacitorScannerPlugin)
-public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetadataOutputObjectsDelegate, AVCapturePhotoCaptureDelegate {
+public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetadataOutputObjectsDelegate, AVCapturePhotoCaptureDelegate, RectangleDetectorDelegate {
 	public let identifier = "CapacitorScannerPlugin"
 	public let jsName = "CapacitorScanner"
 	public let pluginMethods: [CAPPluginMethod] = [
@@ -46,18 +45,11 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 	private var capturePhotoCall: CAPPluginCall?
 
 	private var orientationObserver: NSObjectProtocol?
-	private var videoDataOutput: AVCaptureVideoDataOutput? // For getting video frames
-	private var currentPixelBuffer: CVPixelBuffer? // Store the current pixel buffer for rectangle detection
+	private var videoDataOutput: AVCaptureVideoDataOutput?
 
-	// Motion detection properties
-	private var motionManager: CMMotionManager?
-	private var isDeviceStable = true
-	private let motionThreshold: Double = 0.1 // Threshold for determining if device is moving
-
-	// Rectangle visibility tracking properties
-	private var lastRectangleDetectionTime: Date?
+	// Barcode visibility tracking
 	private var lastBarcodeDetectionTime: Date?
-	private let rectangleVisibilityTimeout: TimeInterval = 1.0 // Time in seconds before considering rectangle no longer visible
+	private let barcodeVisibilityTimeout: TimeInterval = 1.0
 
  // Detection state (controls what detection runs)
  private var enabledDetectionTypes: Set<String> = []
@@ -65,103 +57,82 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
  private var enabledHighlightTypes: Set<String> = []
  private var overlayView: UIView?
  private var barcodeOverlays: [CAShapeLayer] = []
- private var businessCardOverlays: [CAShapeLayer] = []
 
- // Smoothing & persistent overlay layers (for smooth visuals)
+ // Barcode overlay smoothing
  private var barcodeLayer: CAShapeLayer?
- private var cardLayer: CAShapeLayer?
  private var prevBarcodeRect: CGRect?
- private var prevCardRect: CGRect?
- private let smoothingAlpha: CGFloat = 0.25   // 0..1; lower = more smoothing
+ private let smoothingAlpha: CGFloat = 0.25
  private let overlayAnimDuration: CFTimeInterval = 0.12
 
- // Struct to store both rectangle coordinates and image snapshot
- private struct DetectedRectangle {
- 	let rectangle: VNRectangleObservation
- 	let snapshot: UIImage?
- }
-
- private var lastDetectedRectangle: DetectedRectangle?
- // Minimum confidence threshold for using a detected rectangle
- private let rectangleConfidenceThreshold: Float = 0.8
+ // Rectangle detection (extracted to separate class)
+ private var rectangleDetector: RectangleDetector?
 
-	// This is how we create a Vision request for detecting barcodes
+	// Vision request for detecting barcodes
 	private lazy var barcodeDetectionRequest: VNDetectBarcodesRequest = {
 		let request = VNDetectBarcodesRequest { [weak self] request, error in
-			// This closure is called when Vision finds barcodes
 			self?.processClassification(request, error: error)
 		}
 		return request
 	}()
 
-	// Vision request for rectangle detection (business cards)
-	private lazy var rectangleDetectionRequest: VNDetectRectanglesRequest = {
-		let request = VNDetectRectanglesRequest { [weak self] request, error in
-			self?.processRectangleDetection(request, error: error)
-		}
-		request.maximumObservations = 1
-		request.minimumAspectRatio = 0.5 // Business cards are typically rectangular
-		request.maximumAspectRatio = 0.8 // Allow some variation in orientation
-		request.minimumSize = 0.2 // Minimum size threshold
-		request.minimumConfidence = 0.8 // Confidence threshold
-		request.quadratureTolerance = 45 // Increased tolerance to allow more skewed rectangles
-		return request
-	}()
-
 	@objc func enableObjectDetection(_ call: CAPPluginCall) {
-		guard let types = call.getArray("types", String.self) else {
-			call.reject("Missing or invalid 'type' parameter. Expected array of strings.")
-			return
-		}
-
-		// Only accept "businessCard" - barcode detection is handled separately
-		let filteredTypes = types.filter { $0 == "businessCard" }
-
-		if filteredTypes.isEmpty {
-			call.reject("No valid detection types provided. Only 'businessCard' is supported. Use enableBarcodeDetection() for barcode detection.")
+		// If object detection is already enabled, just return success
+		if self.enabledDetectionTypes.contains("businessCard") {
+			call.resolve([
+				"enabled": true,
+			])
 			return
 		}
 
 		let showHighlight = call.getBool("showHighlight", true)
+		let emitIntervalSeconds = call.getDouble("emitIntervalSeconds") ?? 0
 
 		DispatchQueue.main.async {
-			// Add businessCard to enabled detection types
 			self.enabledDetectionTypes.insert("businessCard")
-			// Add to highlight types if showHighlight is true (default)
+
+			// Initialize rectangle detector if needed
+			if self.rectangleDetector == nil {
+				self.rectangleDetector = RectangleDetector()
+				self.rectangleDetector?.delegate = self
+			}
+
+			// Set the emit interval
+			self.rectangleDetector?.setEmitInterval(emitIntervalSeconds)
+
 			if showHighlight {
 				self.enabledHighlightTypes.insert("businessCard")
+				self.rectangleDetector?.isHighlightEnabled = true
 				self.setupOverlayView()
 			}
 
 			call.resolve([
 				"enabled": true,
-				"types": filteredTypes,
 			])
 		}
 	}
 
 	@objc func disableObjectDetection(_ call: CAPPluginCall) {
 		DispatchQueue.main.async {
-			// Remove businessCard from both detection and highlight types
 			self.enabledDetectionTypes.remove("businessCard")
 			self.enabledHighlightTypes.remove("businessCard")
 
-			// Clear only businessCard overlay (not barcode overlay)
-			self.cardLayer?.removeFromSuperlayer()
-			self.cardLayer = nil
-			self.prevCardRect = nil
-			self.lastDetectedRectangle = nil
-			self.currentPixelBuffer = nil
+			// Reset rectangle detector
+			self.rectangleDetector?.reset()
+			self.rectangleDetector = nil
 
 			call.resolve([
 				"enabled": false,
-				"types": [],
 			])
 		}
 	}
 
 	private func setupOverlayView() {
-		guard let cameraView = self.cameraView else { return }
+		guard let cameraView = self.cameraView,
+		      let previewLayer = self.previewLayer else {
+			print("[CapacitorScanner] setupOverlayView: cameraView or previewLayer is nil")
+			return
+		}
+		print("[CapacitorScanner] setupOverlayView: setting up overlay")
 
 		// Remove existing overlay if present
 		self.overlayView?.removeFromSuperview()
@@ -172,24 +143,23 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 		overlay.isUserInteractionEnabled = false
 		cameraView.addSubview(overlay)
 		self.overlayView = overlay
+
+		// Configure rectangle detector with overlay
+		if self.enabledHighlightTypes.contains("businessCard") {
+			self.rectangleDetector?.configure(overlayLayer: overlay.layer, previewLayer: previewLayer)
+		}
 	}
 
  private func clearAllOverlays() {
-		// Remove all barcode overlays (legacy)
+		// Remove barcode overlays
 		self.barcodeOverlays.forEach { $0.removeFromSuperlayer() }
 		self.barcodeOverlays.removeAll()
-
-		// Remove all business card overlays (legacy)
-		self.businessCardOverlays.forEach { $0.removeFromSuperlayer() }
-		self.businessCardOverlays.removeAll()
-
-		// Remove persistent layers used for smoothing
 		self.barcodeLayer?.removeFromSuperlayer()
-		self.cardLayer?.removeFromSuperlayer()
 		self.barcodeLayer = nil
-		self.cardLayer = nil
 		self.prevBarcodeRect = nil
-		self.prevCardRect = nil
+
+		// Reset rectangle detector
+		self.rectangleDetector?.reset()
 
 		// Remove overlay view
 		self.overlayView?.removeFromSuperview()
@@ -242,45 +212,6 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 		}
 	}
 
- private func drawBusinessCardOverlay(for observation: VNRectangleObservation) {
-		guard self.enabledHighlightTypes.contains("businessCard"),
-		      let overlayView = self.overlayView,
-		      let previewLayer = self.previewLayer else { return }
-
-		// Convert Vision coordinates to preview layer coordinates
-		let targetRect = self.convertVisionToPreviewCoordinates(boundingBox: observation.boundingBox, previewLayer: previewLayer)
-
-		DispatchQueue.main.async {
-			let layer: CAShapeLayer
-			if let existing = self.cardLayer {
-				layer = existing
-			} else {
-				let newLayer = CAShapeLayer()
-				newLayer.strokeColor = UIColor.black.cgColor
-				newLayer.fillColor = UIColor.black.withAlphaComponent(0.2).cgColor
-				newLayer.lineWidth = 2.0
-				overlayView.layer.addSublayer(newLayer)
-				self.cardLayer = newLayer
-				layer = newLayer
-			}
-
-			// IoU-based damping for large jumps
-			let basePrev = self.prevCardRect ?? targetRect
-			let dampingAlpha: CGFloat = (self.iou(basePrev, targetRect) < 0.15) ? 0.15 : self.smoothingAlpha
-			let displayedRect = self.lerpRect(basePrev, targetRect, dampingAlpha)
-			self.prevCardRect = displayedRect
-
-			let path = UIBezierPath(roundedRect: displayedRect, cornerRadius: 8.0)
-			CATransaction.begin()
-			CATransaction.setAnimationDuration(self.overlayAnimDuration)
-			CATransaction.setDisableActions(false)
-			layer.path = path.cgPath
-			CATransaction.commit()
-
-			self.lastRectangleDetectionTime = Date()
-		}
-	}
-
 	private func convertVisionToPreviewCoordinates(boundingBox: CGRect, previewLayer: AVCaptureVideoPreviewLayer) -> CGRect {
 		// Vision coordinates are normalized (0-1) with origin at bottom-left
 		// UIKit coordinates have origin at top-left
@@ -350,51 +281,43 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 			return
 		}
 
-		// Check if object detection is enabled and we have a detected rectangle with sufficient confidence
+		// Check if object detection is enabled and we have a detected rectangle
 		if self.enabledDetectionTypes.contains("businessCard"),
-		   let detectedRect = self.lastDetectedRectangle { // Only use rectangles with sufficient confidence
+		   let detectedRect = self.rectangleDetector?.lastDetectedRectangle {
 			// If we have a snapshot from the detection, use it directly
 			if let snapshot = detectedRect.snapshot {
-				// Crop the snapshot to the detected rectangle
-				if let croppedImage = self.cropImage(snapshot, toRectangle: detectedRect.rectangle) {
-					// Convert cropped image back to data
+				if let croppedImage = self.cropImage(snapshot, toRectangle: detectedRect.observation) {
 					guard let croppedImageData = croppedImage.jpegData(compressionQuality: 0.9) else {
 						self.capturePhotoCall?.reject("Unable to convert cropped image to data")
 						return
 					}
-
 					let base64String = croppedImageData.base64EncodedString()
 					self.capturePhotoCall?.resolve(["imageBase64": "data:image/jpeg;base64, \(base64String)"])
 				} else {
-					// If cropping fails, return the original image
 					let base64String = imageData.base64EncodedString()
 					self.capturePhotoCall?.resolve(["imageBase64": "data:image/jpeg;base64, \(base64String)"])
 				}
 			} else {
-				// If no snapshot is available, use the captured photo
+				// Use the captured photo if no snapshot available
 				guard let image = UIImage(data: imageData) else {
 					self.capturePhotoCall?.reject("Unable to create image from data")
 					return
 				}
 
-				// Crop the image to the detected rectangle
-				if let croppedImage = self.cropImage(image, toRectangle: detectedRect.rectangle) {
-					// Convert cropped image back to data
+				if let croppedImage = self.cropImage(image, toRectangle: detectedRect.observation) {
 					guard let croppedImageData = croppedImage.jpegData(compressionQuality: 0.9) else {
 						self.capturePhotoCall?.reject("Unable to convert cropped image to data")
 						return
 					}
-
 					let base64String = croppedImageData.base64EncodedString()
 					self.capturePhotoCall?.resolve(["imageBase64": "data:image/jpeg;base64, \(base64String)"])
 				} else {
-					// If cropping fails, return the original image
 					let base64String = imageData.base64EncodedString()
 					self.capturePhotoCall?.resolve(["imageBase64": "data:image/jpeg;base64, \(base64String)"])
 				}
 			}
 		} else {
-			// If object detection is not enabled or no rectangle is detected, return the original image
+			// No rectangle detected, return original image
 			let base64String = imageData.base64EncodedString()
 			self.capturePhotoCall?.resolve(["imageBase64": "data:image/jpeg;base64, \(base64String)"])
 		}
@@ -462,42 +385,6 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
         return UIImage(cgImage: cgImage, scale: image.scale, orientation: .up)
     }
 
-	private func startDeviceMotionMonitoring() {
-		// Initialize motion manager if needed
-		if self.motionManager == nil {
-			self.motionManager = CMMotionManager()
-		}
-
-		guard let motionManager = self.motionManager, motionManager.isDeviceMotionAvailable else {
-			print("Device motion is not available")
-			return
-		}
-
-		// Set update interval
-		motionManager.deviceMotionUpdateInterval = 0.1
-
-		// Start device motion updates
-		motionManager.startDeviceMotionUpdates(to: .main) { [weak self] (motion, error) in
-			guard let self = self, let motion = motion else { return }
-
-			// Calculate total acceleration magnitude
-			let userAcceleration = motion.userAcceleration
-			let accelerationMagnitude = sqrt(
-				pow(userAcceleration.x, 2) +
-				pow(userAcceleration.y, 2) +
-				pow(userAcceleration.z, 2)
-			)
-
-			// Update device stability status
-			self.isDeviceStable = accelerationMagnitude < self.motionThreshold
-		}
-	}
-
-	private func stopDeviceMotionMonitoring() {
-		self.motionManager?.stopDeviceMotionUpdates()
-	}
-
-
  // Linear interpolation helpers for smoothing
  private func lerp(_ a: CGFloat, _ b: CGFloat, _ t: CGFloat) -> CGFloat {
  	return a + (b - a) * t
@@ -512,14 +399,6 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
  	)
  }
 
- private func iou(_ a: CGRect, _ b: CGRect) -> CGFloat {
- 	let inter = a.intersection(b)
- 	if inter.isNull { return 0 }
- 	let interArea = inter.width * inter.height
- 	let unionArea = a.width * a.height + b.width * b.height - interArea
- 	return unionArea > 0 ? interArea / unionArea : 0
- }
-
 	@objc func start(_ call: CAPPluginCall) {
 		// Read detection options (defaults to false)
 		let enableBarcodeDetection = call.getBool("barcodeDetection", false)
@@ -532,8 +411,6 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 			// Stop any existing session first (must be on main thread for UI operations)
 			self.stopInternal()
 
-			// Initialize timestamp properties
-			self.lastRectangleDetectionTime = nil
 			self.lastBarcodeDetectionTime = nil
 
 			// Enable barcode detection if requested
@@ -550,6 +427,15 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 				if enableObjectHighlight {
 					self.enabledHighlightTypes.insert("businessCard")
 				}
+				// Initialize rectangle detector
+				self.rectangleDetector = RectangleDetector()
+				self.rectangleDetector?.delegate = self
+				if enableObjectHighlight {
+					self.rectangleDetector?.isHighlightEnabled = true
+				}
+				// Set emit interval if provided
+				let emitInterval = call.getDouble("rectangleEmitIntervalSeconds") ?? 0
+				self.rectangleDetector?.setEmitInterval(emitInterval)
 			}
 
 			// Handle Regex Filter
@@ -569,8 +455,6 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 				self.regexFilter = nil
 			}
 
-			// Start monitoring device motion
-			self.startDeviceMotionMonitoring()
 			let captureSession = AVCaptureSession()
 			let cameraDirection: AVCaptureDevice.Position = call.getString("cameraDirection", "BACK") == "BACK" ? .back : .front
 			guard let videoCaptureDevice = self.getCaptureDevice(position: cameraDirection) else {
@@ -666,29 +550,27 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 			captureSession.stopRunning()
 		}
 
-		// Stop monitoring device motion
-		self.stopDeviceMotionMonitoring()
-
 		self.previewLayer?.removeFromSuperlayer()
 		self.cameraView?.removeFromSuperview()
 		self.videoDataOutput?.setSampleBufferDelegate(nil, queue: nil)
-		self.lastDetectedRectangle = nil
 
 		self.captureSession = nil
 		self.cameraView = nil
 		self.previewLayer = nil
 		self.videoDataOutput = nil
-		self.currentPixelBuffer = nil
 		self.scannedCodesVotes.clear()
 		self.regexFilter = nil
-			self.clearAllOverlays()
-			self.showWebViewBackground()
-			self.enabledDetectionTypes.removeAll()
-			self.enabledHighlightTypes.removeAll()
-			self.lastRectangleDetectionTime = nil
-			self.lastBarcodeDetectionTime = nil
-			self.removeOrientationChangeObserver()
 
+		// Reset rectangle detector
+		self.rectangleDetector?.reset()
+		self.rectangleDetector = nil
+
+		self.clearAllOverlays()
+		self.showWebViewBackground()
+		self.enabledDetectionTypes.removeAll()
+		self.enabledHighlightTypes.removeAll()
+		self.lastBarcodeDetectionTime = nil
+		self.removeOrientationChangeObserver()
 	}
 
 	private func addOrientationChangeObserver() {
@@ -908,104 +790,17 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 		}
 	}
 
-	private func processRectangleDetection(_ request: VNRequest, error: Error?) {
-    		// Handle any errors
-    		if let error = error {
-    			print("Rectangle detection error: \(error)")
-    			return
-    		}
-
-    		guard let observations = request.results as? [VNRectangleObservation] else {
-    			return
-    		}
-
-    		// Find the rectangle with highest confidence
-    		if let bestCandidate = observations.max(by: { $0.confidence < $1.confidence }) {
-    			// Check if all four corners are inside the screen limits (normalized coordinates 0-1)
-    			let corners = [
-    				bestCandidate.topLeft,
-    				bestCandidate.topRight,
-    				bestCandidate.bottomLeft,
-    				bestCandidate.bottomRight
-    			]
-
-                let isInsideScreen = corners.allSatisfy { point in
-                    // Define the common minimum and maximum allowed normalized coordinates
-                    let bufferMin: CGFloat = 0.1 // Minimum allowed coordinate (e.g., 10% from each edge)
-                    let bufferMax: CGFloat = 1.0 - bufferMin // Maximum allowed coordinate
-
-                    // Check if both X and Y coordinates of the point are within the allowed range
-                    return point.x >= bufferMin && point.x <= bufferMax &&
-                           point.y >= bufferMin && point.y <= bufferMax
-                }
-    			// Only process if all edges are inside the screen
-    			if isInsideScreen {
-    				// Store the detected rectangle for later use (e.g., image cropping) only if confidence exceeds threshold
-    				if bestCandidate.confidence >= self.rectangleConfidenceThreshold {
-    					// Always store the rectangle coordinates
-    					let rectangle = bestCandidate
-
-   						// Always attempt to capture a snapshot for the accepted rectangle
-   						if let pixelBuffer = self.currentPixelBuffer {
-   							let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
-   							let context = CIContext(options: nil)
-   							if let cgImage = context.createCGImage(ciImage, from: ciImage.extent) {
-   								// Create UIImage with the correct orientation (match Vision handler)
-   								let deviceOrientation = UIDevice.current.orientation
-   								let uiOrientation: UIImage.Orientation
-   								switch deviceOrientation {
-   								case .landscapeLeft:
-   									uiOrientation = .right
-   								case .landscapeRight:
-   									uiOrientation = .left
-   								case .portraitUpsideDown:
-   									uiOrientation = .down
-   								default:
-   									uiOrientation = .up // Default to portrait
-   								}
-   								let snapshot = UIImage(cgImage: cgImage, scale: 1.0, orientation: uiOrientation)
-   								self.lastDetectedRectangle = DetectedRectangle(rectangle: rectangle, snapshot: snapshot)
-   							} else {
-   								// Fallback: store rectangle without snapshot
-   								self.lastDetectedRectangle = DetectedRectangle(rectangle: rectangle, snapshot: nil)
-   							}
-   						} else {
-   							// No pixel buffer available; store rectangle without snapshot
-   							self.lastDetectedRectangle = DetectedRectangle(rectangle: rectangle, snapshot: nil)
-   						}
-    				}
-
-    				// Update the last rectangle detection time
-    				self.lastRectangleDetectionTime = Date()
-
-    				// Draw overlay for business card shape
-    				self.drawBusinessCardOverlay(for: bestCandidate)
-
-    				self.notifyListeners("rectangleDetected", data: [
-    					"topLeft": [
-    						"x": bestCandidate.topLeft.x,
-    						"y": bestCandidate.topLeft.y,
-
-    					],
-    					"topRight": [
-    						"x": bestCandidate.topRight.x,
-    						"y": bestCandidate.topRight.y,
-
-    					],
-    					"bottomLeft": [
-    						"x": bestCandidate.bottomLeft.x,
-    						"y": bestCandidate.bottomLeft.y,
-
-    					],
-    					"bottomRight": [
-    						"x": bestCandidate.bottomRight.x,
-    						"y": bestCandidate.bottomRight.y,
-
-    					],
-    				])
-    			}
-    		}
-    	}
+	// MARK: - RectangleDetectorDelegate
+
+	func rectangleDetector(_ detector: RectangleDetector, didDetect corners: RectangleCorners) {
+		print("[CapacitorScanner] rectangleDetector delegate called - emitting rectangleDetected event")
+		self.notifyListeners("rectangleDetected", data: [
+			"topLeft": ["x": corners.topLeft.x, "y": corners.topLeft.y],
+			"topRight": ["x": corners.topRight.x, "y": corners.topRight.y],
+			"bottomLeft": ["x": corners.bottomLeft.x, "y": corners.bottomLeft.y],
+			"bottomRight": ["x": corners.bottomRight.x, "y": corners.bottomRight.y],
+		])
+	}
 
 	@objc func flipCamera(_ call: CAPPluginCall) {
 		guard let session = self.captureSession else {
@@ -1169,20 +964,13 @@ extension CapacitorScannerPlugin: AVCaptureVideoDataOutputSampleBufferDelegate {
 	                          didOutput sampleBuffer: CMSampleBuffer,
 	                          from connection: AVCaptureConnection)
 	{
-		// This is called for every frame from the camera
-
-		// 1. Get the pixel buffer from the frame
 		guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
 			return
 		}
 
-		// Store the pixel buffer for rectangle detection
-		self.currentPixelBuffer = pixelBuffer
-
-		// 2. Create a Vision image handler with the correct orientation
+		// Determine orientation for Vision
 		let deviceOrientation = UIDevice.current.orientation
 		let cgOrientation: CGImagePropertyOrientation
-
 		switch deviceOrientation {
 		case .landscapeLeft:
 			cgOrientation = .right
@@ -1191,46 +979,45 @@ extension CapacitorScannerPlugin: AVCaptureVideoDataOutputSampleBufferDelegate {
 		case .portraitUpsideDown:
 			cgOrientation = .down
 		default:
-			cgOrientation = .up // Default to portrait
+			cgOrientation = .up
 		}
 
-		let imageRequestHandler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer,
-		                                                orientation: cgOrientation,
-		                                                options: [:])
+		let imageRequestHandler = VNImageRequestHandler(
+			cvPixelBuffer: pixelBuffer,
+			orientation: cgOrientation,
+			options: [:]
+		)
 
-		// 3. Prepare requests based on enabled detection types
+		// Prepare detection requests
 		var requests: [VNRequest] = []
 
-		// Only include barcode detection if enabled
 		if self.enabledDetectionTypes.contains("barcode") {
 			requests.append(self.barcodeDetectionRequest)
 		}
 
-		// Add rectangle detection if business card detection is enabled
-		if self.enabledDetectionTypes.contains("businessCard") {
-			requests.append(self.rectangleDetectionRequest)
+		if self.enabledDetectionTypes.contains("businessCard"),
+		   let detector = self.rectangleDetector {
+			print("[CapacitorScanner] Processing frame for businessCard detection")
+			detector.updatePixelBuffer(pixelBuffer)
+			requests.append(detector.visionRequest)
 		}
 
-  // 4. Perform the detection requests
+		// Perform detection
 		do {
 			try imageRequestHandler.perform(requests)
 		} catch {
 			print("Failed to perform Vision request: \(error)")
 		}
 
-		// Centralized overlay visibility based on last detection timestamps
+		// Check overlay timeouts
 		DispatchQueue.main.async {
 			let now = Date()
-			if let t = self.lastBarcodeDetectionTime, now.timeIntervalSince(t) > self.rectangleVisibilityTimeout {
+			if let t = self.lastBarcodeDetectionTime, now.timeIntervalSince(t) > self.barcodeVisibilityTimeout {
 				self.barcodeLayer?.removeFromSuperlayer()
 				self.barcodeLayer = nil
 				self.prevBarcodeRect = nil
 			}
-			if let t = self.lastRectangleDetectionTime, now.timeIntervalSince(t) > self.rectangleVisibilityTimeout {
-				self.cardLayer?.removeFromSuperlayer()
-				self.cardLayer = nil
-				self.prevCardRect = nil
-			}
+			self.rectangleDetector?.checkTimeout()
 		}
 	}
 }