Matrixscan Batch Ios

//
//  AVFoundationViewController.swift
//
//  Source fixture: an AVFoundation AVCaptureMetadataOutput multi-barcode scanner
//  that accumulates every barcode it sees into a dedup-by-value list.
//  Used as input for the third-party-migration eval — migrate this to MatrixScan
//  Batch (BarcodeBatch), which tracks every visible barcode simultaneously.
//

import UIKit
import AVFoundation

struct ScannedBarcode: Hashable {
    let value: String
    let symbology: String
}

class ViewController: UIViewController {

    private let session = AVCaptureSession()
    private var previewLayer: AVCaptureVideoPreviewLayer!

    // Accumulated, de-duplicated set of everything seen so far.
    private(set) var scannedBarcodes: [ScannedBarcode] = []
    private var seenValues = Set<String>()

    @IBOutlet weak var countLabel: UILabel!

    override func viewDidLoad() {
        super.viewDidLoad()
        setupCamera()
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        if !session.isRunning {
            DispatchQueue.global(qos: .userInitiated).async {
                self.session.startRunning()
            }
        }
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        if session.isRunning {
            session.stopRunning()
        }
    }

    private func setupCamera() {
        guard let videoDevice = AVCaptureDevice.default(for: .video),
              let videoInput = try? AVCaptureDeviceInput(device: videoDevice),
              session.canAddInput(videoInput) else {
            print("Camera not available")
            return
        }
        session.addInput(videoInput)

        let metadataOutput = AVCaptureMetadataOutput()
        guard session.canAddOutput(metadataOutput) else {
            print("Cannot add metadata output")
            return
        }
        session.addOutput(metadataOutput)

        metadataOutput.setMetadataObjectsDelegate(self, queue: .main)
        // Multi-barcode: every type we care about, tracked at once.
        metadataOutput.metadataObjectTypes = [.ean13, .code128, .qr]

        previewLayer = AVCaptureVideoPreviewLayer(session: session)
        previewLayer.frame = view.layer.bounds
        previewLayer.videoGravity = .resizeAspectFill
        view.layer.addSublayer(previewLayer)
    }

    private func symbologyName(for type: AVMetadataObject.ObjectType) -> String {
        switch type {
        case .ean13: return "EAN-13"
        case .code128: return "Code 128"
        case .qr: return "QR"
        default: return "Unknown"
        }
    }
}

extension ViewController: AVCaptureMetadataOutputObjectsDelegate {
    func metadataOutput(_ output: AVCaptureMetadataOutput,
                        didOutput metadataObjects: [AVMetadataObject],
                        from connection: AVCaptureConnection) {
        // AVFoundation reports every barcode in frame on each callback.
        for object in metadataObjects {
            guard let readable = object as? AVMetadataMachineReadableCodeObject,
                  let value = readable.stringValue else { continue }

            guard !seenValues.contains(value) else { continue }
            seenValues.insert(value)

            let entry = ScannedBarcode(value: value, symbology: symbologyName(for: readable.type))
            scannedBarcodes.append(entry)
        }
        countLabel.text = "\(scannedBarcodes.count) unique barcodes"
    }
}

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
    }
}

import UIKit

class ScanViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
    }
}

import ScanditBarcodeCapture
import UIKit

class ScanViewController: UIViewController {

    private lazy var context: DataCaptureContext = {
        DataCaptureContext.initialize(licenseKey: "-- ENTER YOUR SCANDIT LICENSE KEY HERE --")
        return DataCaptureContext.shared
    }()
    private var camera: Camera?
    private var barcodeBatch: BarcodeBatch!
    private var captureView: DataCaptureView!
    private var overlay: BarcodeBatchBasicOverlay!

    override func viewDidLoad() {
        super.viewDidLoad()
        setupRecognition()
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        barcodeBatch.isEnabled = true
        camera?.switch(toDesiredState: .on)
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        barcodeBatch.isEnabled = false
        camera?.switch(toDesiredState: .off)
    }

    private func setupRecognition() {
        camera = Camera.default
        context.setFrameSource(camera, completionHandler: nil)

        let cameraSettings = BarcodeBatch.recommendedCameraSettings
        camera?.apply(cameraSettings, completionHandler: nil)

        let settings = BarcodeBatchSettings()
        settings.set(symbology: .ean13UPCA, enabled: true)
        settings.set(symbology: .code128, enabled: true)

        barcodeBatch = BarcodeBatch(context: context, settings: settings)
        barcodeBatch.addListener(self)

        captureView = DataCaptureView(context: context, frame: view.bounds)
        captureView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        view.addSubview(captureView)

        overlay = BarcodeBatchBasicOverlay(barcodeBatch: barcodeBatch, view: captureView)
    }
}

extension ScanViewController: BarcodeBatchListener {

    func barcodeBatch(
        _ barcodeBatch: BarcodeBatch,
        didUpdate session: BarcodeBatchSession,
        frameData: FrameData
    ) {
        let addedData = session.addedTrackedBarcodes.compactMap { $0.barcode.data }
        DispatchQueue.main.async {
            for data in addedData {
                _ = data
            }
        }
    }
}

{
  "pins" : [
    {
      "identity" : "datacapture-spm",
      "kind" : "remoteSourceControl",
      "location" : "https://github.com/Scandit/datacapture-spm",
      "state" : {
        "revision" : "abc123def456",
        "version" : "6.28.1"
      }
    }
  ],
  "version" : 2
}

//
//  ViewControllerV6.swift
//
//  Source fixture: a Scandit SDK v6 MatrixScan view controller using the old
//  BarcodeTracking API. Used as input for the version-migration eval —
//  migrate this to the v7+ BarcodeBatch API.
//

import UIKit
import ScanditBarcodeCapture

class ViewController: UIViewController {

    // v6-style context construction (deprecated constructor)
    private let context = DataCaptureContext(licenseKey: "-- ENTER YOUR SCANDIT LICENSE KEY HERE --")

    private var camera: Camera?
    private var barcodeTracking: BarcodeTracking!
    private var captureView: DataCaptureView!
    private var overlay: BarcodeTrackingBasicOverlay!

    override func viewDidLoad() {
        super.viewDidLoad()

        // v6-style camera setup: explicit CameraSettings with .auto resolution
        let cameraSettings = CameraSettings()
        cameraSettings.preferredResolution = .auto
        camera = Camera.default
        camera?.apply(cameraSettings)
        context.setFrameSource(camera)

        let settings = BarcodeTrackingSettings()
        settings.set(symbology: .ean13UPCA, enabled: true)
        settings.set(symbology: .code128, enabled: true)

        barcodeTracking = BarcodeTracking(context: context, settings: settings)
        barcodeTracking.addListener(self)

        captureView = DataCaptureView(context: context, frame: view.bounds)
        captureView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        view.addSubview(captureView)

        overlay = BarcodeTrackingBasicOverlay(barcodeTracking: barcodeTracking, view: captureView)
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        barcodeTracking.isEnabled = true
        camera?.switch(toDesiredState: .on)
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        barcodeTracking.isEnabled = false
        camera?.switch(toDesiredState: .off)
    }

    deinit {
        barcodeTracking.removeListener(self)
    }
}

extension ViewController: BarcodeTrackingListener {
    func barcodeTracking(_ barcodeTracking: BarcodeTracking,
                         didUpdate session: BarcodeTrackingSession,
                         frameData: FrameData) {
        let addedData = session.addedTrackedBarcodes.compactMap { $0.barcode.data }
        DispatchQueue.main.async {
            for data in addedData {
                _ = data
            }
        }
    }
}

{
  "skill_name": "matrixscan-batch-ios",
  "evals": [
    {
      "id": 1,
      "prompt": "I want to add MatrixScan Batch to my iOS app. Here's my empty view controller: EmptyViewController.swift. I need to scan EAN-13 and QR barcodes. Please show me the complete updated view controller code in your response.",
      "expected_output": "The skill reads integration.md, returns complete BarcodeBatch integration code inline (DataCaptureContext via DataCaptureContext.initialize + .shared, Camera.default with BarcodeBatch.recommendedCameraSettings, BarcodeBatch(context:settings:), DataCaptureView added as subview, BarcodeBatchBasicOverlay, BarcodeBatchListener with barcodeBatch(_:didUpdate:frameData:), lifecycle on viewWillAppear/viewWillDisappear, removeListener in deinit), and shows the setup checklist.",
      "files": [
        "fixtures/EmptyViewController.swift"
      ],
      "assertions": [
        {
          "text": "Setup checklist is shown and mentions adding ScanditBarcodeCapture and ScanditCaptureCore via Swift Package Manager"
        },
        {
          "text": "Setup checklist mentions adding NSCameraUsageDescription to Info.plist"
        },
        {
          "text": "A license key placeholder string is present"
        },
        {
          "text": "import ScanditBarcodeCapture is added"
        },
        {
          "text": "DataCaptureContext.initialize(licenseKey: is called and DataCaptureContext.shared is used"
        },
        {
          "text": "BarcodeBatchSettings is constructed and configured"
        },
        {
          "text": "Symbology .ean13UPCA is enabled via settings.set(symbology:enabled:) (semantic)"
        },
        {
          "text": "Symbology .qr is enabled (semantic)"
        },
        {
          "text": "Camera.default is used to obtain the camera"
        },
        {
          "text": "BarcodeBatch.recommendedCameraSettings is applied via camera?.apply(_:completionHandler:) (semantic)"
        },
        {
          "text": "context.setFrameSource(camera, completionHandler:) is called (semantic)"
        },
        {
          "text": "BarcodeBatch(context: settings:) convenience initializer is used (not a factory like .forDataCaptureContext)"
        },
        {
          "text": "barcodeBatch.addListener( is called"
        },
        {
          "text": "DataCaptureView(context:frame:) is used and added with view.addSubview (semantic)"
        },
        {
          "text": "BarcodeBatchBasicOverlay(barcodeBatch:view:) is called (semantic)"
        },
        {
          "text": "BarcodeBatchListener is implemented with barcodeBatch(_:didUpdate:frameData:)"
        },
        {
          "text": "The didUpdate callback dispatches UI work via DispatchQueue.main.async"
        },
        {
          "text": "viewWillAppear turns the camera on (camera?.switch(toDesiredState: .on)) and sets barcodeBatch.isEnabled = true"
        },
        {
          "text": "viewWillDisappear turns the camera off (camera?.switch(toDesiredState: .off)) and sets barcodeBatch.isEnabled = false"
        },
        {
          "text": "deinit calls barcodeBatch.removeListener(self)"
        }
      ]
    },
    {
      "id": 2,
      "prompt": "I want to highlight EAN-13 barcodes in green and CODE128 barcodes in blue in my MatrixScan Batch view controller. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill conforms to BarcodeBatchBasicOverlayDelegate, implements barcodeBatchBasicOverlay(_:brushFor:) to return colored Brushes per symbology, and assigns overlay.delegate = self.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "BarcodeBatchBasicOverlayDelegate is adopted (e.g. via an extension)"
        },
        {
          "text": "barcodeBatchBasicOverlay(_:brushFor:) is implemented (semantic)"
        },
        {
          "text": ".ean13UPCA returns a green Brush"
        },
        {
          "text": ".code128 returns a blue Brush"
        },
        {
          "text": "overlay.delegate = self (or equivalent) is assigned"
        },
        {
          "text": "Response mentions that per-barcode brush customization requires the MatrixScan AR add-on license"
        },
        {
          "text": "Existing integration code (BarcodeBatch initializer, DataCaptureView, BarcodeBatchListener, camera lifecycle) is preserved"
        }
      ],
      "tags": [
        "basic-overlay-brush"
      ]
    },
    {
      "id": 3,
      "prompt": "In my MatrixScan Batch view controller I want to log all currently tracked barcodes — their tracking identifier and data — on every frame. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill updates barcodeBatch(_:didUpdate:frameData:) to iterate over session.trackedBarcodes and log each TrackedBarcode's identifier and barcode.data, copying data out of the session before DispatchQueue.main.async.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "session.trackedBarcodes is accessed"
        },
        {
          "text": "Each TrackedBarcode's identifier is used"
        },
        {
          "text": "Each TrackedBarcode's barcode.data is used"
        },
        {
          "text": "Data is copied out of the session before DispatchQueue.main.async (session.trackedBarcodes is not accessed inside the async block)"
        },
        {
          "text": "Existing integration code (BarcodeBatch initializer, camera setup, overlay, lifecycle) is preserved"
        }
      ]
    },
    {
      "id": 4,
      "prompt": "I want to add MatrixScan Batch to my SwiftUI app. Here's my empty ContentView: ContentView.swift. I need to scan EAN-13 and Code128 barcodes. Please show me the complete updated code in your response.",
      "expected_output": "The skill recognizes the SwiftUI path, creates a UIKit ScanViewController containing all BarcodeBatch APIs (context, mode, settings, camera, DataCaptureView, BarcodeBatchBasicOverlay, BarcodeBatchListener, lifecycle, deinit cleanup), and wraps it in a UIViewControllerRepresentable. The SwiftUI View struct contains no Scandit-specific code beyond using the representable. The setup checklist is shown.",
      "files": [
        "fixtures/ContentView.swift"
      ],
      "assertions": [
        {
          "text": "A UIViewControllerRepresentable is defined that wraps a UIKit UIViewController"
        },
        {
          "text": "All BarcodeBatch APIs (DataCaptureContext, BarcodeBatch, BarcodeBatchSettings, DataCaptureView, BarcodeBatchListener, camera lifecycle) live inside the UIKit view controller, NOT inside the SwiftUI View struct"
        },
        {
          "text": "The SwiftUI View struct contains no Scandit-specific code beyond referencing the representable"
        },
        {
          "text": "import ScanditBarcodeCapture is added"
        },
        {
          "text": "DataCaptureContext.initialize(licenseKey: is called and DataCaptureContext.shared is used"
        },
        {
          "text": "Symbology .ean13UPCA is enabled via settings.set(symbology:enabled:) (semantic)"
        },
        {
          "text": "Symbology .code128 is enabled (semantic)"
        },
        {
          "text": "Camera.default is used and BarcodeBatch.recommendedCameraSettings is applied via camera?.apply(_:completionHandler:) (semantic)"
        },
        {
          "text": "context.setFrameSource(camera, completionHandler:) is called (semantic)"
        },
        {
          "text": "BarcodeBatch(context: settings:) convenience initializer is used"
        },
        {
          "text": "DataCaptureView is created and added with view.addSubview inside the view controller"
        },
        {
          "text": "BarcodeBatchBasicOverlay(barcodeBatch:view:) is called (semantic)"
        },
        {
          "text": "BarcodeBatchListener is implemented with barcodeBatch(_:didUpdate:frameData:)"
        },
        {
          "text": "The didUpdate callback dispatches UI work via DispatchQueue.main.async"
        },
        {
          "text": "viewWillAppear turns the camera on and sets barcodeBatch.isEnabled = true"
        },
        {
          "text": "viewWillDisappear turns the camera off and sets barcodeBatch.isEnabled = false"
        },
        {
          "text": "deinit calls barcodeBatch.removeListener(self)"
        },
        {
          "text": "Setup checklist is shown and mentions adding ScanditBarcodeCapture and ScanditCaptureCore via Swift Package Manager"
        },
        {
          "text": "Setup checklist mentions adding NSCameraUsageDescription to Info.plist"
        },
        {
          "text": "A license key placeholder string is present"
        }
      ]
    },
    {
      "id": 5,
      "prompt": "I want to show a small label above each tracked barcode in my MatrixScan Batch view controller — the label should display the barcode's data. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill adds a BarcodeBatchAdvancedOverlay to the view controller, conforms to BarcodeBatchAdvancedOverlayDelegate, implements barcodeBatchAdvancedOverlay(_:viewFor:) to return a UILabel (or other UIView) showing trackedBarcode.barcode.data, and mentions that BarcodeBatchAdvancedOverlay requires the MatrixScan AR add-on license. Existing integration code (basic overlay, listener, lifecycle) is preserved.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "BarcodeBatchAdvancedOverlay(barcodeBatch:view:) is created and stored on the view controller (semantic)"
        },
        {
          "text": "advancedOverlay.delegate = self (or equivalent) is assigned"
        },
        {
          "text": "BarcodeBatchAdvancedOverlayDelegate is adopted (e.g. via an extension)"
        },
        {
          "text": "barcodeBatchAdvancedOverlay(_:viewFor:) is implemented and returns a UIView (e.g. UILabel) that displays trackedBarcode.barcode.data (semantic)"
        },
        {
          "text": "Response mentions that BarcodeBatchAdvancedOverlay requires the MatrixScan AR add-on license"
        },
        {
          "text": "Existing integration code (BarcodeBatch initializer, BarcodeBatchBasicOverlay, BarcodeBatchListener, camera lifecycle) is preserved"
        }
      ],
      "tags": [
        "advanced-overlay-view"
      ]
    },
    {
      "id": 6,
      "prompt": "In my MatrixScan Batch view controller the highlights are drawn as rectangular frames. I'd prefer the dot style instead. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill changes the BarcodeBatchBasicOverlay construction to pass the .dot style via the style: parameter of the convenience initializer, keeping the rest of the integration intact. It may mention that the style is read-only after construction (set it at init time) and that dotRadius tunes dot size.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "BarcodeBatchBasicOverlay(barcodeBatch:view:style:) is used (the style-parameter convenience initializer)"
        },
        {
          "text": "The style passed is .dot"
        },
        {
          "text": "The style is set at construction time, not assigned to overlay.style afterward (style is read-only)"
        },
        {
          "text": "Existing integration code (BarcodeBatch initializer, DataCaptureView, BarcodeBatchListener, camera lifecycle) is preserved"
        }
      ],
      "tags": [
        "basic-overlay-style"
      ]
    },
    {
      "id": 7,
      "prompt": "When the user taps a highlighted barcode in my MatrixScan Batch view, I want to print the tapped barcode's data. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill conforms to BarcodeBatchBasicOverlayDelegate, implements barcodeBatchBasicOverlay(_:didTap:) to read trackedBarcode.barcode.data, assigns overlay.delegate = self, and notes that the tap callback fires on the main thread and that the delegate requires the MatrixScan AR add-on license. Because brushFor is a required protocol member, the skill also implements it returning a real brush (e.g. BarcodeBatchBasicOverlay.defaultBrush(forStyle: overlay.style)) — NOT nil — so highlights stay visible and remain tappable.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "BarcodeBatchBasicOverlayDelegate is adopted (e.g. via an extension)"
        },
        {
          "text": "barcodeBatchBasicOverlay(_:didTap:) is implemented (semantic)"
        },
        {
          "text": "trackedBarcode.barcode.data is read inside the didTap callback"
        },
        {
          "text": "(semantic) the required barcodeBatchBasicOverlay(_:brushFor:) member returns a real brush (e.g. BarcodeBatchBasicOverlay.defaultBrush(forStyle:) or a custom Brush), NOT nil, so highlights remain visible and tappable"
        },
        {
          "text": "overlay.delegate = self (or equivalent) is assigned"
        },
        {
          "text": "Response mentions that using the BarcodeBatchBasicOverlayDelegate requires the MatrixScan AR add-on license"
        },
        {
          "text": "Existing integration code (BarcodeBatch initializer, DataCaptureView, BarcodeBatchListener, camera lifecycle) is preserved"
        }
      ],
      "tags": [
        "basic-overlay-tap"
      ]
    },
    {
      "id": 8,
      "prompt": "I already show a label above each tracked barcode using a BarcodeBatchAdvancedOverlay, but the labels overlap the codes. I want each label anchored to the top-center of its barcode and offset upward by one label height. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill implements barcodeBatchAdvancedOverlay(_:anchorFor:) returning .topCenter and barcodeBatchAdvancedOverlay(_:offsetFor:) returning a PointWithUnit built from FloatWithUnit values in fraction units, keeping the existing viewFor implementation. It notes these delegate methods run on the main thread.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "barcodeBatchAdvancedOverlay(_:anchorFor:) is implemented and returns .topCenter (semantic)"
        },
        {
          "text": "barcodeBatchAdvancedOverlay(_:offsetFor:) is implemented and returns a PointWithUnit (semantic)"
        },
        {
          "text": "The offset PointWithUnit is built with PointWithUnit(x:y:) from FloatWithUnit values (semantic)"
        },
        {
          "text": "FloatWithUnit(value:unit:) is used with unit .fraction for the offset components (semantic)"
        },
        {
          "text": "The vertical offset moves the view upward (a negative y FloatWithUnit value)"
        },
        {
          "text": "Existing integration code (BarcodeBatchAdvancedOverlay creation, viewFor delegate method, BarcodeBatchListener, camera lifecycle) is preserved"
        }
      ],
      "tags": [
        "advanced-overlay-positioning"
      ]
    },
    {
      "id": 9,
      "prompt": "In my MatrixScan Batch view controller I keep a running set of scanned barcode data. When a barcode leaves the camera view I want to remove it from that set. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill updates barcodeBatch(_:didUpdate:frameData:) to read session.removedTrackedBarcodes (an array of Int tracking identifiers), copies it out before dispatching, and removes the matching entries on the main thread. It explains removedTrackedBarcodes holds the tracking identifiers of barcodes that left the frame, not TrackedBarcode objects.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "session.removedTrackedBarcodes is accessed inside barcodeBatch(_:didUpdate:frameData:)"
        },
        {
          "text": "The response treats session.removedTrackedBarcodes as an array of Int tracking identifiers (not TrackedBarcode objects)"
        },
        {
          "text": "The removed identifiers are copied out of the session before DispatchQueue.main.async (session.removedTrackedBarcodes is not accessed inside the async block)"
        },
        {
          "text": "UI/state updates that react to removal are dispatched via DispatchQueue.main.async"
        },
        {
          "text": "Existing integration code (BarcodeBatch initializer, camera setup, overlay, lifecycle) is preserved"
        }
      ],
      "tags": [
        "removed-barcodes"
      ]
    },
    {
      "id": 10,
      "prompt": "I want my MatrixScan Batch app to play a beep and vibrate each time a new barcode starts being tracked. Here is my view controller: IntegratedViewController.swift",
      "expected_output": "The skill explains that BarcodeBatch has no built-in feedback (unlike BarcodeCapture/SparkScan), so feedback must be emitted manually. It calls Feedback.default.emit() from inside barcodeBatch(_:didUpdate:frameData:) when session.addedTrackedBarcodes is non-empty, dispatched to the main thread.",
      "files": [
        "fixtures/IntegratedViewController.swift"
      ],
      "assertions": [
        {
          "text": "Response explains that BarcodeBatch does NOT emit feedback automatically and it must be triggered manually (semantic)"
        },
        {
          "text": "Feedback.default is used to obtain the default feedback"
        },
        {
          "text": "Feedback.default.emit() is called (the emit() method triggers sound and vibration)"
        },
        {
          "text": "Feedback is emitted in response to session.addedTrackedBarcodes being non-empty (new barcodes this frame)"
        },
        {
          "text": "The emit() call is dispatched on the main thread via DispatchQueue.main.async"
        },
        {
          "text": "Existing integration code (BarcodeBatch initializer, camera setup, overlay, lifecycle) is preserved"
        }
      ],
      "tags": [
        "feedback"
      ]
    }
  ]
}

{
  "skill_name": "matrixscan-batch-ios",
  "evals": [
    {
      "id": 1,
      "prompt": "Replace my AVFoundation AVCaptureMetadataOutput multi-barcode scanner with Scandit MatrixScan Batch. Every visible barcode (EAN-13, Code 128, QR) should be tracked at once and accumulated into a dedup list. Here is my view controller: AVFoundationViewController.swift",
      "expected_output": "The skill removes the AVFoundation stack (AVCaptureSession / AVCaptureDeviceInput / AVCaptureMetadataOutput / AVCaptureVideoPreviewLayer setup, the AVCaptureMetadataOutputObjectsDelegate metadataOutput callback, the AVMetadataObject.ObjectType usage) and replaces it with MatrixScan Batch: DataCaptureContext.initialize + .shared, manual camera setup via Camera.default + BarcodeBatch.recommendedCameraSettings + context.setFrameSource, BarcodeBatchSettings with .ean13UPCA + .code128 + .qr, BarcodeBatch(context:settings:), DataCaptureView added with addSubview, BarcodeBatchBasicOverlay(barcodeBatch:view:), a BarcodeBatchListener whose barcodeBatch(_:didUpdate:frameData:) reads session.addedTrackedBarcodes (copied out, then dispatched to DispatchQueue.main.async). The ScannedBarcode model and the dedup logic are preserved. The setup checklist is shown.",
      "files": [
        "fixtures/AVFoundationViewController.swift"
      ],
      "assertions": [
        {
          "text": "import AVFoundation is NOT present in the output"
        },
        {
          "text": "import ScanditBarcodeCapture IS present in the output"
        },
        {
          "text": "The AVCaptureSession / AVCaptureDeviceInput / AVCaptureDevice setup is removed (semantic)"
        },
        {
          "text": "The AVCaptureMetadataOutput instance and its setMetadataObjectsDelegate wiring are removed (semantic)"
        },
        {
          "text": "The AVCaptureMetadataOutputObjectsDelegate conformance and its metadataOutput(_:didOutput:from:) callback are removed (semantic)"
        },
        {
          "text": "The AVCaptureVideoPreviewLayer is removed and replaced by a DataCaptureView (semantic)"
        },
        {
          "text": "DataCaptureContext.initialize(licenseKey: is used and DataCaptureContext.shared is read"
        },
        {
          "text": "BarcodeBatchSettings is constructed"
        },
        {
          "text": "Symbology .ean13UPCA is enabled (mapped from AVMetadataObject.ObjectType.ean13) (semantic)"
        },
        {
          "text": "Symbology .code128 is enabled (mapped from .code128) (semantic)"
        },
        {
          "text": "Symbology .qr is enabled (mapped from .qr) (semantic)"
        },
        {
          "text": "Camera.default is used to obtain the camera"
        },
        {
          "text": "BarcodeBatch.recommendedCameraSettings is applied via camera?.apply(_:completionHandler:) (semantic)"
        },
        {
          "text": "context.setFrameSource(camera, completionHandler:) is called (semantic)"
        },
        {
          "text": "BarcodeBatch(context: settings:) convenience initializer is used"
        },
        {
          "text": "DataCaptureView(context:frame:) is created and added with view.addSubview (semantic)"
        },
        {
          "text": "BarcodeBatchBasicOverlay(barcodeBatch:view:) is called (semantic)"
        },
        {
          "text": "The view controller conforms to BarcodeBatchListener and implements barcodeBatch(_:didUpdate:frameData:)"
        },
        {
          "text": "barcodeBatch(_:didUpdate:frameData:) reads session.addedTrackedBarcodes (the new-this-frame collection)"
        },
        {
          "text": "Session data is copied out before DispatchQueue.main.async and UI/state updates run inside DispatchQueue.main.async"
        },
        {
          "text": "The existing ScannedBarcode struct is preserved in the output"
        },
        {
          "text": "The deduplication logic (the seenValues set / checking before appending) is preserved in the new flow"
        },
        {
          "text": "Setup checklist is shown and mentions adding ScanditBarcodeCapture and ScanditCaptureCore via Swift Package Manager"
        },
        {
          "text": "Setup checklist mentions adding NSCameraUsageDescription to Info.plist"
        },
        {
          "text": "A summary of changes is shown with Removed and Added sections"
        }
      ],
      "tags": [
        "third-party-migration"
      ]
    }
  ]
}

{
  "skill_name": "matrixscan-batch-ios",
  "evals": [
    {
      "id": 1,
      "prompt": "I need to upgrade my iOS MatrixScan app from Scandit SDK v6 to v7. Here is my current view controller: ViewControllerV6.swift.",
      "expected_output": "The skill renames every v6 BarcodeTracking* type to its v7 BarcodeBatch* equivalent (mode, settings, listener, session, basic overlay) and renames the listener delegate method barcodeTracking(_:didUpdate:frameData:) to barcodeBatch(_:didUpdate:frameData:). It modernizes the context to DataCaptureContext.initialize(licenseKey:) + DataCaptureContext.shared and the camera setup to BarcodeBatch.recommendedCameraSettings. The convenience-initializer shape BarcodeBatch(context:settings:) is preserved. Provides the v6→v7 migration guide URL.",
      "files": [
        "fixtures/ViewControllerV6.swift"
      ],
      "assertions": [
        {
          "text": "The BarcodeTracking mode type is renamed to BarcodeBatch in the rewritten code blocks"
        },
        {
          "text": "BarcodeTrackingSettings is renamed to BarcodeBatchSettings in the rewritten code blocks"
        },
        {
          "text": "BarcodeTrackingSession is renamed to BarcodeBatchSession in the rewritten code blocks"
        },
        {
          "text": "BarcodeTrackingListener is renamed to BarcodeBatchListener in the rewritten code blocks"
        },
        {
          "text": "BarcodeTrackingBasicOverlay is renamed to BarcodeBatchBasicOverlay in the rewritten code blocks"
        },
        {
          "text": "The listener delegate method barcodeBatch(_:didUpdate:frameData:) is present in the rewritten code blocks"
        },
        {
          "text": "The old delegate method barcodeTracking(_:didUpdate:frameData:) is NOT present in the rewritten code blocks"
        },
        {
          "text": "No BarcodeTracking-named identifier remains in the rewritten code blocks"
        },
        {
          "text": "DataCaptureContext.initialize(licenseKey: is present in the rewritten code blocks"
        },
        {
          "text": "DataCaptureContext.shared is read after initialize"
        },
        {
          "text": "The deprecated DataCaptureContext(licenseKey:) constructor is NOT used in the rewritten code blocks (semantic)"
        },
        {
          "text": "BarcodeBatch.recommendedCameraSettings is used for camera setup"
        },
        {
          "text": "The v6 hand-rolled CameraSettings() with preferredResolution = .auto is NOT present in the rewritten code blocks"
        },
        {
          "text": "The BarcodeBatch(context:settings:) convenience initializer shape is preserved (not changed to a factory like .forDataCaptureContext) (semantic)"
        },
        {
          "text": "The iOS lifecycle (viewWillAppear / viewWillDisappear) and deinit removeListener are preserved through the rename"
        },
        {
          "text": "The v6→v7 migration guide URL https://docs.scandit.com/sdks/ios/migrate-6-to-7/ is provided"
        }
      ],
      "tags": [
        "version-migration"
      ]
    },
    {
      "id": 2,
      "prompt": "I'm upgrading my Scandit iOS MatrixScan Batch SDK from v7 to v8. What do I need to change in my code?",
      "expected_output": "The skill explains that native iOS BarcodeBatch has no breaking API changes in v7→v8 — the BarcodeBatch(context:settings:) initializer, BarcodeBatchListener, BarcodeBatchSession, and the overlays are unchanged. The only thing to watch for is the VideoResolution.auto deprecation in custom camera settings. It does NOT tell the user to swap BarcodeBatch(context:settings:) for a different constructor + addMode pattern (that change is for cross-platform SDKs only). Provides the v7→v8 migration guide URL.",
      "files": [],
      "assertions": [
        {
          "text": "The skill states there are no breaking API changes for native iOS BarcodeBatch in v7→v8"
        },
        {
          "text": "VideoResolution.auto (or .auto resolution) deprecation is mentioned"
        },
        {
          "text": "The skill does NOT instruct the user to replace BarcodeBatch(context:settings:) with a different constructor + addMode pattern (that is a cross-platform SDK change) (semantic)"
        },
        {
          "text": "The skill does NOT instruct the user to rename BarcodeBatch(context:settings:) to a factory method (semantic)"
        },
        {
          "text": "The v7→v8 migration guide URL https://docs.scandit.com/sdks/ios/migrate-7-to-8/ is provided"
        }
      ],
      "tags": [
        "version-migration"
      ]
    },
    {
      "id": 3,
      "prompt": "I want to upgrade my MatrixScan Batch iOS integration to the latest Scandit SDK version. Here's my code and Package.resolved.",
      "expected_output": "The skill reads Package.resolved to detect v6.28.1, determines the target is v8, and applies both migrations in order (6→7 then 7→8) without asking the user for their version. The 6→7 BarcodeTracking→BarcodeBatch rename and context/camera modernization are applied.",
      "files": [
        "fixtures/ViewControllerV6.swift",
        "fixtures/Package_v6.resolved"
      ],
      "assertions": [
        {
          "text": "Summary mentions the detected version (6.28.1 or v6)"
        },
        {
          "text": "Did not ask the user for their version — proceeded autonomously"
        },
        {
          "text": "No BarcodeTracking-named identifier remains in the rewritten code blocks (6→7 rename applied)"
        },
        {
          "text": "BarcodeBatch is used as the mode type in the rewritten code blocks"
        },
        {
          "text": "DataCaptureContext.initialize(licenseKey: is present in the rewritten code blocks"
        },
        {
          "text": "The deprecated DataCaptureContext(licenseKey:) constructor is NOT used in the rewritten code blocks (semantic)"
        },
        {
          "text": "BarcodeBatch.recommendedCameraSettings is used (camera setup updated)"
        },
        {
          "text": "The v6 hand-rolled CameraSettings() with preferredResolution = .auto is NOT present in the rewritten code blocks"
        }
      ],
      "tags": [
        "version-migration"
      ]
    }
  ]
}