Building a Live Barcode and Text Scanner in Rork Max with VisionKit's DataScanner

import VisionKit
 
enum ScannerAvailability {
    case ready
    case cameraDenied        // not authorized -> guide to Settings
    case unsupportedDevice   // simulator / A11 or earlier
    case restricted          // parental controls, etc.
 
    static func current() -> ScannerAvailability {
        // isSupported only reflects device/OS capability, not authorization
        guard DataScannerViewController.isSupported else {
            return .unsupportedDevice
        }
        // isAvailable is true only when supported AND authorized AND usable
        guard DataScannerViewController.isAvailable else {
            let status = AVCaptureDevice.authorizationStatus(for: .video)
            return status == .restricted ? .restricted : .cameraDenied
        }
        return .ready
    }
}

import SwiftUI
import VisionKit
 
struct DataScannerView: UIViewControllerRepresentable {
    let recognizedTypes: Set<DataScannerViewController.RecognizedDataType>
    @Binding var isScanning: Bool
    let onScan: (RecognizedItem) -> Void
 
    func makeUIViewController(context: Context) -> DataScannerViewController {
        let controller = DataScannerViewController(
            recognizedDataTypes: recognizedTypes,
            qualityLevel: .balanced,
            recognizesMultipleItems: false,
            isHighFrameRateTrackingEnabled: true,
            isPinchToZoomEnabled: true,
            isGuidanceEnabled: true,
            isHighlightingEnabled: true
        )
        controller.delegate = context.coordinator
        return controller
    }
 
    func updateUIViewController(_ controller: DataScannerViewController, context: Context) {
        // Start or stop scanning to match the parent state
        if isScanning {
            try? controller.startScanning()
        } else {
            controller.stopScanning()
        }
    }
 
    func makeCoordinator() -> Coordinator { Coordinator(self) }
 
    final class Coordinator: NSObject, DataScannerViewControllerDelegate {
        private let parent: DataScannerView
        private var lastFired: [String: Date] = [:]
 
        init(_ parent: DataScannerView) { self.parent = parent }
 
        func dataScanner(_ scanner: DataScannerViewController,
                         didAdd addedItems: [RecognizedItem],
                         allItems: [RecognizedItem]) {
            for item in addedItems { handle(item) }
        }
 
        func dataScanner(_ scanner: DataScannerViewController,
                         didTapOn item: RecognizedItem) {
            handle(item)
        }
 
        // Do not re-notify the same content for 1.5 seconds
        private func handle(_ item: RecognizedItem) {
            let key = stableKey(for: item)
            let now = Date()
            if let last = lastFired[key], now.timeIntervalSince(last) < 1.5 { return }
            lastFired[key] = now
            parent.onScan(item)
        }
 
        private func stableKey(for item: RecognizedItem) -> String {
            switch item {
            case .barcode(let code):
                return "barcode:" + (code.payloadStringValue ?? "")
            case .text(let text):
                return "text:" + text.transcript
            @unknown default:
                return "unknown"
            }
        }
    }
}

let types: Set<DataScannerViewController.RecognizedDataType> = [
    .barcode(symbologies: [.qr, .ean13, .code128]),
    .text(languages: ["en", "ja"])
]

struct ScannerScreen: View {
    @State private var availability: ScannerAvailability = .unsupportedDevice
    @State private var isScanning = true
    @State private var lastResult = ""
 
    private let types: Set<DataScannerViewController.RecognizedDataType> = [
        .barcode(symbologies: [.qr, .ean13, .code128]),
        .text(languages: ["en", "ja"])
    ]
 
    var body: some View {
        Group {
            switch availability {
            case .ready:
                DataScannerView(recognizedTypes: types, isScanning: $isScanning) { item in
                    switch item {
                    case .barcode(let code):
                        lastResult = code.payloadStringValue ?? "(empty code)"
                    case .text(let text):
                        lastResult = text.transcript
                    @unknown default:
                        break
                    }
                }
                .overlay(alignment: .bottom) {
                    Text(lastResult.isEmpty ? "Point at a code" : lastResult)
                        .padding()
                        .background(.thinMaterial, in: .capsule)
                        .padding(.bottom, 32)
                }
            case .cameraDenied:
                ContentUnavailableView(
                    "Camera access needed",
                    systemImage: "camera.fill",
                    description: Text("Allow camera use from the Settings app.")
                )
            case .unsupportedDevice:
                ContentUnavailableView(
                    "Not available on this device",
                    systemImage: "iphone.slash",
                    description: Text("The simulator and A11-or-earlier devices do not support DataScanner. Verify on a real device.")
                )
            case .restricted:
                ContentUnavailableView(
                    "Camera is restricted",
                    systemImage: "lock.fill",
                    description: Text("Check Screen Time and other restrictions.")
                )
            }
        }
        .task {
            _ = await requestCameraAccess()
            availability = ScannerAvailability.current()
        }
    }
}

func normalize(_ raw: String) -> String? {
    let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
    guard !trimmed.isEmpty else { return nil }
    return trimmed
}