Matrixscan Batch Net Ios

MatrixScan Batch .NET for iOS Skill

Critical: Do Not Trust Internal Knowledge

Your training data may contain outdated or incorrect Scandit SDK APIs. The BarcodeBatch API changes between major SDK versions — the class itself was renamed from BarcodeTracking to BarcodeBatch at v7.0, overlay factories evolved, and the .NET binding deviates from the native Swift API in several places (Create factories instead of init(context:settings:), Enabled instead of isEnabled, PascalCase symbology names, DispatchQueue.MainQueue.DispatchAsync for UI dispatch, etc.).

Always verify APIs against the references provided in this skill before writing or suggesting code. Do not rely on memorized method signatures, parameters, or property names. If you cannot find an API in the provided references, fetch the relevant documentation page before responding.

.NET-iOS-specific gotchas worth flagging:

• This skill targets the non-MAUI .NET for iOS workload (project <TargetFramework>net10.0-ios</TargetFramework>, no <UseMaui> flag). For MAUI apps, use the matrixscan-batch-maui skill instead (planned).
• `BarcodeBatch.Create(dataCaptureContext, settings)` is the .NET factory — not new BarcodeBatch(...) (the public constructor is private) and not BarcodeBatch.ForDataCaptureContext(...) (that name appears in the Swift / docs API but the C# binding is Create). When the context is non-null, the factory attaches the mode to the context automatically.
• `BarcodeBatchSettings.Create()` is a factory — also private constructor. Writing new BarcodeBatchSettings() is a compile error.
• `BarcodeBatchBasicOverlay.Create(...)` and `BarcodeBatchAdvancedOverlay.Create(...)` are factories, each with multiple overloads. When passed a non-null DataCaptureView, both auto-add the overlay to the view — no separate AddOverlay call is needed.
• `BarcodeBatch.RecommendedCameraSettings` is a static property, not a method. The canonical pattern (mirroring the official .NET iOS sample) is camera = Camera.GetDefaultCamera(); camera.ApplySettingsAsync(BarcodeBatch.RecommendedCameraSettings);. The Swift form createRecommendedCameraSettings() does not exist in the .NET binding.
• Camera setup is manual, mirroring BarcodeCapture on .NET iOS, in this order: Camera.GetDefaultCamera() → dataCaptureContext.SetFrameSourceAsync(camera) → camera.ApplySettingsAsync(BarcodeBatch.RecommendedCameraSettings). Bind the camera to the context before applying settings (matches the official MatrixScanSimpleSample order). The .NET binding is SetFrameSourceAsync — not the synchronous Swift setFrameSource(_:completionHandler:).
• `DataCaptureView.Create(dataCaptureContext, frame)` takes a `CGRect` as the second argument on iOS — different from the Android Create(dataCaptureContext) overload. The canonical call site is DataCaptureView.Create(dataCaptureContext, this.View!.Bounds). Set AutoresizingMask = UIViewAutoresizing.FlexibleHeight | UIViewAutoresizing.FlexibleWidth and add it with this.View.AddSubview(dataCaptureView) followed by this.View.SendSubviewToBack(dataCaptureView).
• View-controller constructor depends on how the VC is instantiated. If the VC is inflated by a storyboard / XIB (typical when the project has a Main.storyboard with UIMainStoryboardFile set in Info.plist), keep the public MyViewController(IntPtr handle) : base(handle) { } constructor — the runtime calls it with a real native handle. For programmatically-instantiated VCs (no Main.storyboard, root view controller set from SceneDelegate.WillConnect or AppDelegate), declare a parameterless public MyViewController() : base() { } constructor and instantiate via new MyViewController(). Do not pass `IntPtr.Zero` to the `(IntPtr)` ctor — that leaves the native peer uninitialized and ViewDidLoad may never fire, which manifests as a black screen with no camera preview and no scans.
• `IBarcodeBatchListener.OnSessionUpdated(BarcodeBatch, BarcodeBatchSession, IFrameData)` runs on a background recognition queue — not the main queue. Dispatch any UI work via DispatchQueue.MainQueue.DispatchAsync(() => { … }). The third parameter is IFrameData (the .NET binding), not FrameData (Swift).
• Always call `frameData.Dispose()` at the end of every `OnSessionUpdated` callback (including any early-return path). The official iOS sample explicitly disposes the frame to avoid a "frozen, non-responsive, or severely stuttering" video feed. This is not optional on iOS, and is a difference from the Android skill where the disposal is not required.
• The .NET binding also exposes the event API on BarcodeBatch: barcodeBatch.SessionUpdated += handler (EventHandler<BarcodeBatchEventArgs>). Use either the listener interface OR the event — not both for the same handler. The event-handler body must still call args.FrameData.Dispose(). There is no BarcodeScanned event on BarcodeBatch (batch is tracking, not single-scan).
• Do not hold references to `BarcodeBatchSession` or its collections outside `OnSessionUpdated`. The session is only safe to access within that callback — copy AddedTrackedBarcodes / UpdatedTrackedBarcodes / TrackedBarcodes data first, then dispatch.
• BarcodeBatchSession properties: AddedTrackedBarcodes (IList<TrackedBarcode>), UpdatedTrackedBarcodes (IList<TrackedBarcode>), RemovedTrackedBarcodes (IList<int> — tracking IDs only, not TrackedBarcode), TrackedBarcodes (IDictionary<int, TrackedBarcode>), FrameSequenceId (long), Reset(). Note: Reset() lives on the Session in the .NET binding (there is no BarcodeBatch.Reset() like the Android Kotlin API has).
• TrackedBarcode properties: Barcode, Identifier (int), Location (Quadrilateral), plus GetAnchorPosition(Anchor). The tracking identifier is reused after a barcode leaves the frame.
• The capture mode's enabled property is barcodeBatch.Enabled (not IsEnabled and not Swift's isEnabled). IDataCaptureMode exposes Enabled in the .NET binding.
• `BarcodeBatchBasicOverlayStyle` is C# PascalCase: Frame (default) and Dot. Not frame / dot (Swift) and not FRAME / DOT (Kotlin).
• Per-barcode brush customization (IBarcodeBatchBasicOverlayListener.BrushForTrackedBarcode and BarcodeBatchBasicOverlay.SetBrushForTrackedBarcode) requires the MatrixScan AR add-on license. A uniform default brush via overlay.Brush = … (no listener) does not require the add-on.
• `BarcodeBatchAdvancedOverlay` (anchoring custom UIViews to tracked barcodes) requires the MatrixScan AR add-on license. IBarcodeBatchAdvancedOverlayListener has ViewForTrackedBarcode(overlay, trackedBarcode) → UIView?, AnchorForTrackedBarcode(...), OffsetForTrackedBarcode(...) — all three are called on the main thread. The return type is UIView? (the .NET binding maps View to UIKit.UIView on iOS via a global using View = UIKit.UIView;).
• BarcodeBatchLicenseInfo (read via barcodeBatch.BarcodeBatchLicenseInfo) is dotnet.ios=8.4+ only. Before 8.4 the property does not exist — gate any usage on the installed SDK version. The value is available once IDataCaptureContextListener.OnModeAdded has been called.
• Symbology names are C# PascalCase: Symbology.Ean13Upca, Symbology.Ean8, Symbology.Upce, Symbology.Code39, Symbology.Code128, Symbology.InterleavedTwoOfFive, Symbology.Qr, Symbology.DataMatrix. They are not Swift's .ean13UPCA / .code128 / .qr style.
• The NuGet packages are Scandit.DataCapture.Core and Scandit.DataCapture.Barcode. No separate *.Maui packages here — those are only for MAUI projects. Do not guess the version from training data — fetch the latest stable from https://www.nuget.org/packages/Scandit.DataCapture.Barcode/ via WebFetch before pinning. Inventing a non-existent version causes dotnet restore to fail with Unable to find package Scandit.DataCapture.Core with version (>= …). See references/integration.md Step 0 for the full procedure.
• iOS `SupportedOSPlatformVersion` must be ≥ `15.0`. Set it in the .csproj. The official MatrixScanSimpleSample Info.plist MinimumOSVersion is 15.0 and the project's <SupportedOSPlatformVersion> matches.
• The required `Info.plist` key is `NSCameraUsageDescription` (Privacy - Camera Usage Description). Without it the app crashes on first camera access. iOS prompts the user automatically the first time the camera opens; there is no separate runtime-request API to call (no Android-style RequestPermissions).
• SDK 8.0+ requires explicit initialization. Call ScanditCaptureCore.Initialize() + ScanditBarcodeCapture.Initialize() in AppDelegate.FinishedLaunching before any Scandit code runs (typically before creating the window / root view controller). Without this the SDK's DI container has no registrations and the first BarcodeBatch.Create(...) / DataCaptureView.Create(...) call crashes at launch. Not required on 6.x / 7.x. See references/integration.md Step 0 / Prerequisites for the full AppDelegate template.

Intent Routing

Based on the user's request, load the appropriate reference file before responding:

• Integrating MatrixScan Batch from scratch, configuring settings, handling tracked barcodes, customizing overlays, anchoring custom UIViews, managing the camera lifecycle, or diagnosing a frozen/stuttering preview (e.g. "add MatrixScan Batch to my .NET iOS app", "scan all barcodes in view at once in C#", "highlight tracked barcodes in green", "anchor a price label to each tracked barcode", "show me how to set up BarcodeBatch in net-ios", "my preview is stuttering after I integrated BarcodeBatch") → read references/integration.md and follow the instructions there.
• Migrating or upgrading an existing MatrixScan Batch integration (e.g. "upgrade from v6 to v7", "rename BarcodeTracking to BarcodeBatch", "bump the Scandit .NET SDK to v8", "what changed between SDK versions for BarcodeBatch") → read references/migration.md and follow the instructions there.
• Replacing a third-party multi-barcode scanner with MatrixScan Batch (e.g. "replace my AVFoundation multi-barcode loop with MatrixScan Batch", "migrate from ZXing.Net.Mobile continuous scanning to Scandit", "switch from AVCaptureMetadataOutput to BarcodeBatch") → read references/third-party-migration.md and follow the instructions there.

API Usage Policy

Only use APIs that are explicitly documented in the Scandit references below. Do not invent or guess method signatures, parameters, or property names. If unsure whether an API exists or how it is called — or if a compile error occurs — fetch the relevant reference page before responding. Do not tell the user to check the docs themselves. After answering, always include the relevant link so the user can explore further.

Never construct or guess documentation URLs. When you need a specific class or property's API page: 1. First check whether the page you already fetched contains a direct hyperlink to it — topic pages link directly to relevant API symbols. Always request links alongside content in your fetch prompt. 2. If no direct link was found, fetch the API index (see Full API reference in the table below), extract the actual link from it, and follow that.

URL structures can vary (e.g. api/ui/ subdirectory) and guessing will lead to 404s.

References

Direct users to the right resource based on their question:

API surface this skill covers

All classes documented with :available: dotnet.ios in the official RST docs (docs/source/barcode-capture/api/barcode-batch*.rst and api/ui/barcode-batch-*-overlay*.rst) are addressed in references/integration.md:

• BarcodeBatch — Create(DataCaptureContext?, BarcodeBatchSettings), Enabled, ApplySettingsAsync(settings), AddListener(IBarcodeBatchListener) / RemoveListener(IBarcodeBatchListener), event SessionUpdated (EventHandler<BarcodeBatchEventArgs>), static RecommendedCameraSettings (property, not method), Context, BarcodeBatchLicenseInfo (8.4+), Dispose.
• BarcodeBatchSettings — Create(), EnableSymbology(Symbology, bool), EnableSymbologies(ICollection<Symbology>), GetSymbologySettings(Symbology), EnabledSymbologies (get), SetProperty / GetProperty<T> / TryGetProperty<T>.
• BarcodeBatchSession — AddedTrackedBarcodes, UpdatedTrackedBarcodes, RemovedTrackedBarcodes (IList<int> of tracking IDs), TrackedBarcodes (IDictionary<int, TrackedBarcode>), FrameSequenceId, Reset().
• BarcodeBatchEventArgs — BarcodeBatch, Session, FrameData.
• IBarcodeBatchListener — OnObservationStarted(BarcodeBatch), OnObservationStopped(BarcodeBatch), OnSessionUpdated(BarcodeBatch, BarcodeBatchSession, IFrameData).
• BarcodeBatchLicenseInfo (8.4+) — LicensedSymbologies.
• TrackedBarcode — Barcode, Identifier, Location (Quadrilateral), GetAnchorPosition(Anchor).
• BarcodeBatchBasicOverlay — Create(barcodeBatch, view, style), Create(barcodeBatch, style), Create(barcodeBatch, view), Create(barcodeBatch), Listener (IBarcodeBatchBasicOverlayListener?), Brush (uniform default brush), static DefaultBrushForStyle(style), Style (read-only), ShouldShowScanAreaGuides, SetBrushForTrackedBarcode(trackedBarcode, brush), ClearTrackedBarcodeBrushes(), Dispose.
• BarcodeBatchBasicOverlayStyle enum — Frame, Dot.
• IBarcodeBatchBasicOverlayListener — BrushForTrackedBarcode(overlay, trackedBarcode), OnTrackedBarcodeTapped(overlay, trackedBarcode). Requires MatrixScan AR add-on.
• BarcodeBatchAdvancedOverlay — Create(barcodeBatch, view), Create(barcodeBatch), Listener (IBarcodeBatchAdvancedOverlayListener?), SetViewForTrackedBarcode(trackedBarcode, UIView?), SetAnchorForTrackedBarcode(trackedBarcode, anchor), SetOffsetForTrackedBarcode(trackedBarcode, offset), ClearTrackedBarcodeViews(), ShouldShowScanAreaGuides, Dispose. Requires MatrixScan AR add-on.
• IBarcodeBatchAdvancedOverlayListener — ViewForTrackedBarcode(overlay, trackedBarcode) → UIView?, AnchorForTrackedBarcode(overlay, trackedBarcode), OffsetForTrackedBarcode(overlay, trackedBarcode). Requires MatrixScan AR add-on.

MatrixScan Batch .NET for iOS Integration Guide

BarcodeBatch is the multi-barcode tracking mode. It simultaneously tracks every barcode visible in the camera feed, reporting additions, position updates, and removals on every frame. Unlike BarcodeCapture (which scans one barcode at a time), BarcodeBatch continuously tracks every barcode in view — it does not stop or disable after a detection. Camera and lifecycle are managed manually, exactly like BarcodeCapture on .NET iOS.

Examples below use C# 12 and a UIViewController. The same APIs work in storyboards, XIBs, or programmatically-instantiated controllers — adapt ownership of DataCaptureContext, BarcodeBatch, and the Camera to the project's existing structure.

Constructor pattern depends on instantiation path. Storyboard / XIB inflation uses public MyVC(IntPtr handle) : base(handle) { }. Programmatic instantiation (no Main.storyboard, root view controller set from SceneDelegate.WillConnect or AppDelegate) needs a parameterless public MyVC() : base() { } and new MyVC(). Never construct a VC with `new MyVC(IntPtr.Zero)` — the native peer is not initialized, ViewDidLoad may never fire, and you'll see a black screen with no preview and no scans. If you support both paths, declare both constructors.

MAUI? Stop. If the project file has <UseMaui>true</UseMaui>, switch to the matrixscan-batch-maui skill. The MAUI integration uses XAML and a UseScanditBarcode builder, which is different.

Prerequisites

Step 0 — Fetch the latest SDK version from NuGet (mandatory, do this before any edits)

Before editing the .csproj, WebFetch https://www.nuget.org/packages/Scandit.DataCapture.Barcode/ and read the latest stable version number off the page (skip -beta.* / -preview.* / -rc.* suffixes). Use that exact version for both packages.

Do not guess, do not reuse a version from training data, and do not invent a number like 8.13.0 when only 8.4.0 is the latest stable — dotnet restore will fail with Unable to find package Scandit.DataCapture.Core with version (>= 8.13.0). The latest stable version changes regularly; only the live NuGet page is authoritative. If WebFetch fails, fall back to https://api.nuget.org/v3-flatcontainer/scandit.datacapture.barcode/index.json (last entry without a pre-release suffix) before proceeding.

MatrixScan Batch on dotnet.ios was first published in 6.16. Anything older does not have a BarcodeBatch API on this platform.

Other prerequisites

• Scandit Data Capture SDK for .NET — add both packages to the .csproj, pinned to the version fetched in Step 0:

  <ItemGroup>
    <PackageReference Include="Scandit.DataCapture.Core" Version="<step-0-version>" />
    <PackageReference Include="Scandit.DataCapture.Barcode" Version="<step-0-version>" />
  </ItemGroup>

Both packages are published on NuGet.org. Do not add Scandit.DataCapture.Core.Maui or Scandit.DataCapture.Barcode.Maui — those are MAUI-only.

• A valid Scandit license key:
• Sign in at https://ssl.scandit.com to generate one.
• No account yet? Sign up at https://ssl.scandit.com/dashboard/sign-up?p=test.
• Camera usage description in `Info.plist`:

  <key>NSCameraUsageDescription</key>
  <string>Used to scan barcodes.</string>

Without this key the app crashes on first camera access. iOS prompts the user for permission automatically the first time the camera is opened; there is no separate runtime-request API to call (the Scandit SDK triggers the standard system prompt when the camera starts). This is different from .NET for Android, which needs a manual RequestPermissions call.

• `SupportedOSPlatformVersion` must be at least `15.0` in the .csproj:

  <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion>

Matches the official MatrixScanSimpleSample Info.plist MinimumOSVersion.

• SDK initialization (Scandit 8.0+). Initialize the Scandit DI container in AppDelegate.FinishedLaunching before any Scandit type is constructed. Without this the first DataCaptureContext.ForLicenseKey(...) / BarcodeBatch.Create(...) / DataCaptureView.Create(...) call crashes because the container has no registrations.

  using Foundation;
  using Scandit.DataCapture.Barcode;
  using Scandit.DataCapture.Core;
  using UIKit;

  namespace MyApp;

  [Register("AppDelegate")]
  public class AppDelegate : UIResponder, IUIApplicationDelegate
  {
      [Export("window")]
      public UIWindow? Window { get; set; }

      [Export("application:didFinishLaunchingWithOptions:")]
      public bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
      {
          ScanditCaptureCore.Initialize();
          ScanditBarcodeCapture.Initialize();
          return true;
      }
  }

If the project already has an AppDelegate, add the two Initialize() calls at the top of FinishedLaunching rather than creating a second delegate. This step is only required on Scandit SDK 8.0+ — earlier majors (6.x, 7.x) self-initialized, so for those versions skip this entirely.

Project scaffolding (new projects only)

If a .NET iOS project already exists, skip this subsection and go to the Integration flow below.

Recommended: scaffold a buildable shell with the official template, then add MatrixScan Batch on top:

dotnet new ios -o MyApp
cd MyApp

This produces a project with the correct OutputType, a working AppDelegate / SceneDelegate, an Info.plist, and storyboard-or-programmatic UI scaffolding. Add the Scandit packages from the bullets above, bump <SupportedOSPlatformVersion> to 15.0 (or higher), add NSCameraUsageDescription to Info.plist, and continue with Step 1.

Integration flow

Ask the user which barcode symbologies they need to scan. When asking, mention that enabling only the symbologies they actually need improves tracking performance and accuracy.

Once the user responds, ask them which UIViewController they'd like to integrate BarcodeBatch into. Then write the integration code directly into that file. Do not just show the code in chat; apply it to the file.

After providing the code, show this setup checklist:

Setup checklist: 1. Add <PackageReference Include="Scandit.DataCapture.Barcode" Version="<step-0-version>" /> and <PackageReference Include="Scandit.DataCapture.Core" Version="<step-0-version>" /> to the .csproj (use the version pinned in Step 0 above — do not guess). 2. Add NSCameraUsageDescription to Info.plist with a short user-facing description. 3. If targeting SDK 8.0+, ensure AppDelegate.FinishedLaunching calls ScanditCaptureCore.Initialize() and ScanditBarcodeCapture.Initialize() before constructing any Scandit type. 4. Ensure <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion> (or higher) is set in the .csproj. 5. Replace -- ENTER YOUR SCANDIT LICENSE KEY HERE -- with your key from https://ssl.scandit.com.

Namespaces

Step 1 — Create the DataCaptureContext

The DataCaptureContext is the central hub of the SDK. Construct it once and reuse the same reference for the lifetime of the scanning surface.

using Scandit.DataCapture.Core.Capture;

private DataCaptureContext dataCaptureContext =
    DataCaptureContext.ForLicenseKey("-- ENTER YOUR SCANDIT LICENSE KEY HERE --");

Step 2 — Configure BarcodeBatchSettings

All symbologies are disabled by default. Enable each one explicitly; enabling only what is needed reduces tracking overhead.

using Scandit.DataCapture.Barcode.Batch.Capture;
using Scandit.DataCapture.Barcode.Data;

BarcodeBatchSettings settings = BarcodeBatchSettings.Create();
settings.EnableSymbology(Symbology.Ean13Upca, true);
settings.EnableSymbology(Symbology.Ean8, true);
settings.EnableSymbology(Symbology.Code128, true);

You can also enable a set of symbologies at once:

settings.EnableSymbologies(new HashSet<Symbology>
{
    Symbology.Ean13Upca,
    Symbology.Code128
});

BarcodeBatchSettings members

Symbology names are C# PascalCase. The full set includes Ean13Upca, Ean8, Upce, Code39, Code93, Code128, InterleavedTwoOfFive, Qr, DataMatrix, Pdf417, Aztec, Codabar, and more. Don't use Swift-style camelCase names (ean13UPCA).

Step 3 — Camera setup

Camera.GetDefaultCamera() returns the back camera. The canonical pattern (matching the official .NET iOS MatrixScanSimpleSample) is to obtain the camera, attach it as the frame source first, then apply BarcodeBatch.RecommendedCameraSettings via ApplySettingsAsync, and drive it from ViewWillAppear / ViewWillDisappear.

Order matters. SetFrameSourceAsync(camera) must be called before camera.ApplySettingsAsync(cameraSettings). This matches the official sample. Reversing the order can leave the preview blank.

using Scandit.DataCapture.Core.Source;

private Camera? camera;

private void SetUpCamera()
{
    this.camera = Camera.GetDefaultCamera();

    if (this.camera != null)
    {
        // 1. Bind the camera to the context FIRST.
        this.dataCaptureContext.SetFrameSourceAsync(this.camera);

        // 2. Then apply camera settings.
        // BarcodeBatch.RecommendedCameraSettings is a static PROPERTY — not a method.
        // The Swift form `recommendedCameraSettings` is a class var; the .NET binding
        // exposes it as a static property here.
        CameraSettings cameraSettings = BarcodeBatch.RecommendedCameraSettings;

        // The official iOS sample bumps to Full HD for better decode range.
        cameraSettings.PreferredResolution = VideoResolution.FullHd;

        this.camera.ApplySettingsAsync(cameraSettings);
    }
}

Switch the camera on / off:

await this.camera?.SwitchToDesiredStateAsync(FrameSourceState.On);   // start preview / tracking
await this.camera?.SwitchToDesiredStateAsync(FrameSourceState.Off);  // release the camera

Camera.GetCamera(CameraPosition.WorldFacing) also returns the back camera explicitly. GetDefaultCamera() returns the recommended camera for the device.

Step 4 — Create the BarcodeBatch mode

this.barcodeBatch = BarcodeBatch.Create(this.dataCaptureContext, settings);

Create(context, settings) is the factory — the constructor is private. When the context argument is non-null, the mode is automatically added to the context (you do not need a separate dataCaptureContext.SetMode(...) call). Passing null for the context creates a detached mode, which you can later attach by passing it to a context.

Re-applying settings at runtime:

await this.barcodeBatch.ApplySettingsAsync(newSettings);

BarcodeBatch members

Use either AddListener or the SessionUpdated event — not both for the same handler. There is no BarcodeScanned event on BarcodeBatch (batch is tracking, not single-scan).

Step 5 — DataCaptureView

DataCaptureView.Create(dataCaptureContext, frame) creates the camera preview as a UIView. The iOS overload takes a CGRect (typically this.View.Bounds) as the second argument — different from the Android Create(dataCaptureContext) form.

using Scandit.DataCapture.Core.UI;
using UIKit;

// In ViewDidLoad / InitializeAndStartBatchScanning, after this.View exists:
var dataCaptureView = DataCaptureView.Create(this.dataCaptureContext, this.View!.Bounds);

UIView platformView = dataCaptureView;
platformView.AutoresizingMask = UIViewAutoresizing.FlexibleHeight |
                                UIViewAutoresizing.FlexibleWidth;

this.View.AddSubview(dataCaptureView);
this.View.SendSubviewToBack(dataCaptureView);

DataCaptureView is a UIView and is not auto-attached to any parent. Call AddSubview explicitly, then SendSubviewToBack so any other subviews (UI chrome, buttons) sit on top of the camera preview. Setting AutoresizingMask ensures the preview resizes correctly on rotation and split-screen.

Step 6 — BarcodeBatchBasicOverlay

BarcodeBatchBasicOverlay renders a highlight frame or dot over each tracked barcode. The Create(barcodeBatch, dataCaptureView, ...) factory auto-adds the overlay to the view — no separate AddOverlay call needed.

using Scandit.DataCapture.Barcode.Batch.UI.Overlay;

// Default style (Frame):
BarcodeBatchBasicOverlay overlay =
    BarcodeBatchBasicOverlay.Create(this.barcodeBatch, dataCaptureView);

// Or choose a style explicitly:
BarcodeBatchBasicOverlay overlay = BarcodeBatchBasicOverlay.Create(
    this.barcodeBatch,
    dataCaptureView,
    BarcodeBatchBasicOverlayStyle.Frame);

BarcodeBatchBasicOverlay members

BarcodeBatchBasicOverlayStyle enum

Per-barcode brush customization (requires MatrixScan AR add-on)

Implement IBarcodeBatchBasicOverlayListener to return a different brush per barcode. BrushForTrackedBarcode is called from the rendering thread.

using UIKit;
using Scandit.DataCapture.Barcode.Batch.UI.Overlay;
using Scandit.DataCapture.Barcode.Batch.Data;
using Scandit.DataCapture.Barcode.Data;
using Brush = Scandit.DataCapture.Core.UI.Style.Brush;

public partial class BatchScanViewController : UIViewController,
    IBarcodeBatchListener,
    IBarcodeBatchBasicOverlayListener
{
    // ... other fields / setup ...

    public Brush? BrushForTrackedBarcode(BarcodeBatchBasicOverlay overlay, TrackedBarcode trackedBarcode)
    {
        // Return null to use the overlay's default brush.
        // Return a fully transparent brush to hide the barcode highlight.
        // UIColor.FromRGBA on iOS takes normalized floats in the 0.0..1.0 range
        // (the official Scandit iOS samples use the `x / 255f` pattern).
        return trackedBarcode.Barcode.Symbology switch
        {
            Symbology.Ean13Upca => new Brush(
                fillColor: UIColor.Green.ColorWithAlpha(0.4f),
                strokeColor: UIColor.Green,
                strokeWidth: 2f),
            _ => null,
        };
    }

    public void OnTrackedBarcodeTapped(BarcodeBatchBasicOverlay overlay, TrackedBarcode trackedBarcode)
    {
        // React to the user tapping a barcode highlight.
    }
}

Assign the listener after creating the overlay:

overlay.Listener = this;

MatrixScan AR add-on required for BrushForTrackedBarcode and SetBrushForTrackedBarcode. A uniform default brush (no listener) does not require the add-on.

Step 7 — IBarcodeBatchListener (or subscribe to SessionUpdated)

Implement IBarcodeBatchListener to receive per-frame session updates. OnSessionUpdated is called on a background recognition queue — do not hold session references outside the callback, dispatch any UI work via DispatchQueue.MainQueue.DispatchAsync, and always call `frameData.Dispose()` before returning (failing to dispose causes a frozen / stuttering preview).

Listener interface (parity with the Swift / Android native APIs)

using CoreFoundation;
using Scandit.DataCapture.Barcode.Batch.Capture;
using Scandit.DataCapture.Barcode.Batch.Data;
using Scandit.DataCapture.Core.Data;

public partial class BatchScanViewController : UIViewController, IBarcodeBatchListener
{
    public void OnSessionUpdated(
        BarcodeBatch barcodeBatch,
        BarcodeBatchSession session,
        IFrameData frameData)
    {
        try
        {
            // Called on a background recognition queue. Copy the data you need…
            var addedData = session.AddedTrackedBarcodes
                .Select(tb => tb.Barcode.Data)
                .Where(d => d != null)
                .Cast<string>()
                .ToList();

            // …then dispatch UI updates onto the main queue.
            DispatchQueue.MainQueue.DispatchAsync(() =>
            {
                foreach (var data in addedData)
                {
                    // handle data
                }
            });
        }
        finally
        {
            // Always dispose the frame, including on the early-return / exception path.
            // Failing to dispose causes a frozen, non-responsive, or stuttering preview.
            frameData.Dispose();
        }
    }

    public void OnObservationStarted(BarcodeBatch barcodeBatch) { }
    public void OnObservationStopped(BarcodeBatch barcodeBatch) { }
}

// In InitializeAndStartBatchScanning:
this.barcodeBatch.AddListener(this);

Event handler (idiomatic C#)

this.barcodeBatch.SessionUpdated += (sender, args) =>
{
    try
    {
        var addedData = args.Session.AddedTrackedBarcodes
            .Select(tb => tb.Barcode.Data)
            .ToList();

        DispatchQueue.MainQueue.DispatchAsync(() =>
        {
            foreach (var data in addedData)
            {
                // handle data
            }
        });
    }
    finally
    {
        args.FrameData.Dispose();
    }
};

IBarcodeBatchListener

BarcodeBatchEventArgs (for the event-based API)

BarcodeBatchSession

Important: Do not hold references to BarcodeBatchSession or its collections outside OnSessionUpdated. Copy any data you need before the callback returns. The session is mutated by the recognition thread on the next frame.

TrackedBarcode

Step 8 — Lifecycle management

Drive the camera and the Enabled flag from ViewWillAppear and ViewWillDisappear. The camera must not be active while the view controller is not visible.

public override void ViewWillAppear(bool animated)
{
    base.ViewWillAppear(animated);
    // Resume processing frames.
    this.barcodeBatch.Enabled = true;
    // Switch the camera on. iOS asks for the camera permission automatically on
    // the first launch when NSCameraUsageDescription is set in Info.plist.
    this.camera?.SwitchToDesiredStateAsync(FrameSourceState.On);
}

public override void ViewWillDisappear(bool animated)
{
    base.ViewWillDisappear(animated);
    // Stop processing frames.
    this.barcodeBatch.Enabled = false;
    // Switch the camera off to release it.
    this.camera?.SwitchToDesiredStateAsync(FrameSourceState.Off);
}

For explicit teardown (e.g. when the scanning view controller is being deallocated), remove the listener and detach the mode:

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        this.barcodeBatch.RemoveListener(this);
        this.dataCaptureContext.RemoveCurrentMode();
    }
    base.Dispose(disposing);
}

Unlike Android (OnResume / OnPause / OnDestroy), iOS lifecycle hooks are ViewWillAppear / ViewWillDisappear (or ViewDidAppear / ViewDidDisappear). No runtime permission check is needed — iOS handles that via the NSCameraUsageDescription plist key the first time the camera opens.

Complete minimal example

This mirrors the structure of the official MatrixScanSimpleSample for .NET iOS.

using System.Collections.Generic;
using System.Linq;
using CoreFoundation;
using Foundation;
using UIKit;

using Scandit.DataCapture.Barcode.Batch.Capture;
using Scandit.DataCapture.Barcode.Batch.Data;
using Scandit.DataCapture.Barcode.Batch.UI.Overlay;
using Scandit.DataCapture.Barcode.Data;
using Scandit.DataCapture.Core.Capture;
using Scandit.DataCapture.Core.Data;
using Scandit.DataCapture.Core.Source;
using Scandit.DataCapture.Core.UI;

namespace MyApp;

public partial class BatchScanViewController : UIViewController, IBarcodeBatchListener
{
    public const string SCANDIT_LICENSE_KEY = "-- ENTER YOUR SCANDIT LICENSE KEY HERE --";

    private DataCaptureContext dataCaptureContext = null!;
    private BarcodeBatch barcodeBatch = null!;
    private Camera? camera;

    private readonly HashSet<string> scannedData = new();

    // Storyboard-loaded VCs: keep this constructor (the runtime calls it with a real handle).
    // Programmatically-instantiated VCs (no Main.storyboard): use the parameterless ctor below
    // and `new BatchScanViewController()`. DO NOT call `new BatchScanViewController(IntPtr.Zero)` —
    // that leaves the native peer uninitialized and ViewDidLoad may never fire.
    public BatchScanViewController(IntPtr handle) : base(handle) { }
    public BatchScanViewController() : base() { }

    public override void ViewDidLoad()
    {
        base.ViewDidLoad();
        this.InitializeAndStartBatchScanning();
    }

    public override void ViewWillAppear(bool animated)
    {
        base.ViewWillAppear(animated);
        this.barcodeBatch.Enabled = true;
        this.camera?.SwitchToDesiredStateAsync(FrameSourceState.On);
    }

    public override void ViewWillDisappear(bool animated)
    {
        base.ViewWillDisappear(animated);
        this.barcodeBatch.Enabled = false;
        this.camera?.SwitchToDesiredStateAsync(FrameSourceState.Off);
    }

    private void InitializeAndStartBatchScanning()
    {
        this.dataCaptureContext = DataCaptureContext.ForLicenseKey(SCANDIT_LICENSE_KEY);

        this.camera = Camera.GetDefaultCamera();
        if (this.camera != null)
        {
            // Bind the camera to the context BEFORE applying settings — matches the
            // official MatrixScanSimpleSample order. Reversing these leaves the preview blank.
            this.dataCaptureContext.SetFrameSourceAsync(this.camera);

            CameraSettings cameraSettings = BarcodeBatch.RecommendedCameraSettings;
            cameraSettings.PreferredResolution = VideoResolution.FullHd;
            this.camera.ApplySettingsAsync(cameraSettings);
        }

        BarcodeBatchSettings settings = BarcodeBatchSettings.Create();
        settings.EnableSymbologies(new HashSet<Symbology>
        {
            Symbology.Ean13Upca,
            Symbology.Code128,
        });

        this.barcodeBatch = BarcodeBatch.Create(this.dataCaptureContext, settings);
        this.barcodeBatch.AddListener(this);

        var dataCaptureView = DataCaptureView.Create(this.dataCaptureContext, this.View!.Bounds);
        UIView platformView = dataCaptureView;
        platformView.AutoresizingMask = UIViewAutoresizing.FlexibleHeight |
                                        UIViewAutoresizing.FlexibleWidth;
        this.View.AddSubview(dataCaptureView);
        this.View.SendSubviewToBack(dataCaptureView);

        BarcodeBatchBasicOverlay.Create(
            this.barcodeBatch,
            dataCaptureView,
            BarcodeBatchBasicOverlayStyle.Frame);
    }

    public void OnSessionUpdated(
        BarcodeBatch barcodeBatch,
        BarcodeBatchSession session,
        IFrameData frameData)
    {
        try
        {
            // Copy the data we need off the recognition queue before dispatching.
            var addedData = session.AddedTrackedBarcodes
                .Select(tb => tb.Barcode.Data)
                .Where(d => d != null)
                .Cast<string>()
                .ToList();

            DispatchQueue.MainQueue.DispatchAsync(() =>
            {
                foreach (var data in addedData)
                {
                    this.scannedData.Add(data);
                }
            });
        }
        finally
        {
            frameData.Dispose();
        }
    }

    public void OnObservationStarted(BarcodeBatch barcodeBatch) { }
    public void OnObservationStopped(BarcodeBatch barcodeBatch) { }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            this.barcodeBatch?.RemoveListener(this);
        }
        base.Dispose(disposing);
    }
}

The official MatrixScanSimpleSample does not override Dispose — it relies on the framework's deterministic teardown. Removing the listener in Dispose(bool) is a safe belt-and-suspenders for VCs that may be recreated. Do not call `dataCaptureContext.RemoveCurrentMode()` here: it can race with the recognition queue and tear down the mode while a frame is still in flight.

Optional: BarcodeBatchAdvancedOverlay (requires MatrixScan AR add-on)

BarcodeBatchAdvancedOverlay anchors a custom UIView to each tracked barcode in real time, retaining its relative position as the barcode moves. The Create factory auto-adds the overlay to the view when given a non-null DataCaptureView.

using UIKit;
using Scandit.DataCapture.Barcode.Batch.UI.Overlay;
using Scandit.DataCapture.Barcode.Batch.Data;
using Scandit.DataCapture.Core.Common.Geometry;

public partial class BatchScanViewController : UIViewController,
    IBarcodeBatchListener,
    IBarcodeBatchAdvancedOverlayListener
{
    private BarcodeBatchAdvancedOverlay advancedOverlay = null!;

    // In InitializeAndStartBatchScanning, after creating dataCaptureView:
    private void SetUpAdvancedOverlay(DataCaptureView dataCaptureView)
    {
        this.advancedOverlay = BarcodeBatchAdvancedOverlay.Create(
            this.barcodeBatch,
            dataCaptureView);
        this.advancedOverlay.Listener = this;
    }

    // Called on the main thread for each tracked barcode.
    // Return a UIView to anchor to this barcode, or null to show nothing.
    public UIView? ViewForTrackedBarcode(
        BarcodeBatchAdvancedOverlay overlay,
        TrackedBarcode trackedBarcode)
    {
        var label = new UILabel
        {
            Text = trackedBarcode.Barcode.Data,
            TextColor = UIColor.Black,
            BackgroundColor = UIColor.White,
            TextAlignment = UITextAlignment.Center,
        };
        label.SizeToFit();
        // Add a little padding around the text.
        label.Frame = new CoreGraphics.CGRect(
            label.Frame.X, label.Frame.Y,
            label.Frame.Width + 16, label.Frame.Height + 8);
        return label;
    }

    public Anchor AnchorForTrackedBarcode(
        BarcodeBatchAdvancedOverlay overlay,
        TrackedBarcode trackedBarcode) => Anchor.TopCenter;

    public PointWithUnit OffsetForTrackedBarcode(
        BarcodeBatchAdvancedOverlay overlay,
        TrackedBarcode trackedBarcode) =>
        new PointWithUnit(
            new FloatWithUnit(0f, MeasureUnit.Fraction),
            new FloatWithUnit(-1f, MeasureUnit.Fraction));
}

To update the view for a specific tracked barcode imperatively (e.g. after an async lookup completes), call the Set*ForTrackedBarcode methods. They are thread-safe.

this.advancedOverlay.SetViewForTrackedBarcode(trackedBarcode, updatedView);
this.advancedOverlay.SetAnchorForTrackedBarcode(trackedBarcode, Anchor.TopCenter);
this.advancedOverlay.SetOffsetForTrackedBarcode(trackedBarcode, offset);
this.advancedOverlay.ClearTrackedBarcodeViews(); // remove all views

BarcodeBatchAdvancedOverlay members

IBarcodeBatchAdvancedOverlayListener

For tap callbacks and additional advanced-overlay options, fetch the Adding AR Overlays page.

Optional: feedback (beep / vibration on a newly tracked barcode)

Unlike single-shot BarcodeCapture — which owns a BarcodeCaptureFeedback and beeps automatically on every accepted scan — and unlike SparkScan, `BarcodeBatch` has no built-in feedback and emits nothing on its own. There is no feedback property on BarcodeBatch or BarcodeBatchSettings. Tracking many codes per frame would otherwise produce a continuous buzz. To beep or vibrate when a code is first tracked, own a Feedback instance yourself and call Emit() from OnSessionUpdated, gated on session.AddedTrackedBarcodes (the barcodes newly tracked this frame).

session.AddedTrackedBarcodes is the right trigger: it is the set added this frame, so it does not re-fire while a code stays in view. If a tracking ID can be reused after a code leaves and re-enters the frame, de-duplicate against a HashSet<int> of identifiers you have already signalled.

using System.Linq;
using Scandit.DataCapture.Core.Common.Feedback;

// Build the Feedback once (as a field) and reuse it; do NOT allocate per frame.
// new Feedback(vibration, sound) — pass null for either component to omit it.
private readonly Feedback feedback =
    new Feedback(Vibration.DefaultVibration, Sound.DefaultSound);
// (or simply: private readonly Feedback feedback = Feedback.DefaultFeedback;)

// Identifiers already signalled, so feedback fires once per newly tracked barcode.
private readonly HashSet<int> signalledTrackingIds = new();

public void OnSessionUpdated(
    BarcodeBatch barcodeBatch,
    BarcodeBatchSession session,
    IFrameData frameData)
{
    try
    {
        // Add() returns true only the first time an identifier is seen, so Emit()
        // fires once per newly tracked barcode rather than on every frame.
        bool firstSighting = session.AddedTrackedBarcodes
            .Any(tb => this.signalledTrackingIds.Add(tb.Identifier));

        if (firstSighting)
        {
            this.feedback.Emit();
        }
    }
    finally
    {
        frameData.Dispose();
    }
}

Feedback.Emit() is influenced by the device ring mode and volume settings, so a correctly configured Sound/Vibration may still be silent on a muted device. Members live in Scandit.DataCapture.Core.Common.Feedback:

Feedback, Vibration and Sound are IDisposable in the .NET binding. Hold the Feedback for the controller's lifetime and let it be released with the controller; do not allocate a new one per frame.

Optional: pause / reset tracking

Optional: BarcodeBatchLicenseInfo (8.4+)

Once the mode has been attached to the context and the context has emitted OnModeAdded, you can inspect which symbologies the active license allows:

using Scandit.DataCapture.Barcode.Batch.Capture;

// After IDataCaptureContextListener.OnModeAdded fires:
BarcodeBatchLicenseInfo? licenseInfo = this.barcodeBatch.BarcodeBatchLicenseInfo;
ICollection<Symbology>? licensed = licenseInfo?.LicensedSymbologies;

BarcodeBatchLicenseInfo is available from Scandit dotnet.ios 8.4 onwards. On earlier versions the property does not exist.

Troubleshooting: frozen, non-responsive, or stuttering preview

Symptom: After integrating BarcodeBatch the camera preview freezes after a few frames, becomes unresponsive, or starts stuttering badly. Tracking updates stop arriving.

Cause: IFrameData (the frameData parameter of OnSessionUpdated, or args.FrameData from the SessionUpdated event) holds onto a native frame buffer. The .NET-iOS binding requires the consumer to explicitly Dispose() it; otherwise the recognition pipeline runs out of buffers and stalls.

Fix: Wrap the body of every OnSessionUpdated callback in a try { ... } finally { frameData.Dispose(); }, so the frame is always disposed — even on the early-return / exception path:

public void OnSessionUpdated(BarcodeBatch barcodeBatch, BarcodeBatchSession session, IFrameData frameData)
{
    try
    {
        // … handle session …
    }
    finally
    {
        frameData.Dispose();
    }
}

The same applies to the event-based API — call args.FrameData.Dispose() in a finally. This is iOS-specific; on Android the binding manages the frame's lifetime for you.

Key rules

1. One context per scanning surface — construct DataCaptureContext.ForLicenseKey(key) once and reuse it. 2. Factory, not constructor — BarcodeBatch.Create(context, settings) is the factory. Both new BarcodeBatch(...) and BarcodeBatch.ForDataCaptureContext(...) are compile errors in the .NET binding. 3. Settings factory too — BarcodeBatchSettings.Create() is the factory; new BarcodeBatchSettings() is a compile error. 4. Manual camera, in this order — Camera.GetDefaultCamera() → dataCaptureContext.SetFrameSourceAsync(camera) → camera.ApplySettingsAsync(BarcodeBatch.RecommendedCameraSettings). Bind the camera to the context before applying settings (matches the official MatrixScanSimpleSample); reversing the order can leave the preview blank. RecommendedCameraSettings is a static property, not a method. 5. DataCaptureView takes a CGRect on iOS — DataCaptureView.Create(dataCaptureContext, this.View!.Bounds), then AutoresizingMask, AddSubview, SendSubviewToBack. 6. Recognition queue — OnSessionUpdated runs on a background queue. Copy the data you need, then dispatch UI work via DispatchQueue.MainQueue.DispatchAsync(() => …). 7. Always dispose `IFrameData` — every OnSessionUpdated (and every SessionUpdated event handler) must call frameData.Dispose() in a finally block. Missing this is the #1 cause of frozen / stuttering previews on iOS. 8. Don't retain the session — the session and its collections are only safe within OnSessionUpdated. Copy data out before the callback returns. 9. Overlay auto-adds — BarcodeBatchBasicOverlay.Create(mode, view, ...) and BarcodeBatchAdvancedOverlay.Create(mode, view) both add themselves to the DataCaptureView automatically when view is non-null. 10. AR add-on gates — per-barcode brush customization (IBarcodeBatchBasicOverlayListener / SetBrushForTrackedBarcode) and BarcodeBatchAdvancedOverlay both require the MatrixScan AR add-on license. 11. `Enabled` for pause/resume — toggle barcodeBatch.Enabled to pause and resume tracking without removing the mode or releasing the camera. 12. Lifecycle cleanup — turn the camera off in ViewWillDisappear(), back on in ViewWillAppear(). If overriding Dispose(bool), call barcodeBatch?.RemoveListener(this) only. Do not call dataCaptureContext.RemoveCurrentMode() from Dispose — it can race with the recognition queue and tear the mode down while a frame is still being processed. The official MatrixScanSimpleSample does not override Dispose at all. 13. Symbologies — all disabled by default; enable only what is needed. Names are PascalCase (Ean13Upca, not .ean13UPCA). 14. No runtime permission call — iOS handles the camera prompt automatically once NSCameraUsageDescription is in Info.plist. There is no Android-style RequestPermissions. 15. SDK 8.0+ initialization — AppDelegate.FinishedLaunching calling ScanditCaptureCore.Initialize() + ScanditBarcodeCapture.Initialize() is mandatory on 8.0+. 16. `IFrameData`, not `FrameData` — the .NET listener signature passes an IFrameData. Don't import FrameData (that's a Swift type). 17. No automatic feedback — BarcodeBatch has no built-in beep/vibration and exposes no feedback property (unlike BarcodeCaptureFeedback / SparkScanFeedback). To signal a new code, own a Feedback (Feedback.DefaultFeedback or new Feedback(Vibration.DefaultVibration, Sound.DefaultSound)) and call feedback.Emit() from OnSessionUpdated, gated on session.AddedTrackedBarcodes. Feedback.DefaultFeedback / Vibration.DefaultVibration / Sound.DefaultSound are static properties, not methods.

MatrixScan Batch .NET for iOS Migration Guide

Step 1: Detect the installed SDK version

Before making any changes, find out which version of the Scandit SDK the project currently has installed.

Check .csproj (and Directory.Packages.props if Central Package Management is in use) for the <PackageReference Include="Scandit.DataCapture.Barcode" Version="..." /> (or Scandit.DataCapture.Core) line. Both packages should be pinned to the same version. If they drift, treat the lowest version as the installed one.

Once you know the installed version, determine which migration path applies:

If you cannot find the version, ask the user which version they are migrating from.

Note: MatrixScan Batch on dotnet.ios was first published in 6.16 (a brief window during the 6 line where the class was still named BarcodeTracking). The cross-platform rename to BarcodeBatch landed at 7.0. Anything older than 6.16 does not have this API on dotnet.ios — confirm with the user before assuming a version below 6.16.

---

Step 2: Update the dependency version

Before touching source files, WebFetch https://www.nuget.org/packages/Scandit.DataCapture.Barcode/ and read the latest stable version. Then update the SDK version in every <PackageReference>:

• Scandit.DataCapture.Core
• Scandit.DataCapture.Barcode

Do not guess. The latest stable version changes regularly; only the live NuGet page is authoritative. If WebFetch fails, fall back to https://api.nuget.org/v3-flatcontainer/scandit.datacapture.barcode/index.json (last entry without a pre-release suffix).

Restore packages (dotnet restore or rebuild in the IDE) before continuing.

---

Step 3: Apply source-code changes

Search for files that use MatrixScan Batch (search for BarcodeBatch, BarcodeBatchSettings, BarcodeBatchSession, BarcodeBatchEventArgs, IBarcodeBatchListener, BarcodeBatchBasicOverlay, BarcodeBatchAdvancedOverlay, and also the v6 names BarcodeTracking, BarcodeTrackingSettings, BarcodeTrackingSession, IBarcodeTrackingListener, BarcodeTrackingBasicOverlay, BarcodeTrackingAdvancedOverlay) and apply the relevant changes below directly to those files.

---

Migration: 6 → 7

The 6→7 step for .NET iOS MatrixScan Batch is primarily about the cross-platform BarcodeTracking → BarcodeBatch rename and the new namespace under Batch.*. Go through every section below and apply each change that matches the project.

BarcodeTracking → BarcodeBatch rename

The class family was renamed at v7.0 across all platforms (iOS, Android, .NET, Flutter, etc.). Apply this rename everywhere the old names appear:

Method names that include BarcodeTracking in the parameter name (e.g. OnObservationStarted(BarcodeTracking barcodeTracking)) become OnObservationStarted(BarcodeBatch barcodeBatch) etc. Update the parameter type and parameter name to match.

Namespace rename

The using directives change with the class names:

Apply a project-wide search-and-replace on Scandit.DataCapture.Barcode.Tracking → Scandit.DataCapture.Barcode.Batch followed by BarcodeTracking → BarcodeBatch. Run the build afterwards and clean up any references the rename missed.

Camera setup — use RecommendedCameraSettings

If the project constructs a CameraSettings by hand (e.g. new CameraSettings { PreferredResolution = ... }), prefer the recommended settings property after the rename:

Before (v6 pattern):

var cameraSettings = new CameraSettings { PreferredResolution = VideoResolution.Auto };
var camera = Camera.GetDefaultCamera();
camera?.ApplySettingsAsync(cameraSettings);

After (v7+ pattern):

var camera = Camera.GetDefaultCamera();
camera?.ApplySettingsAsync(BarcodeBatch.RecommendedCameraSettings);

If a specific resolution (e.g. VideoResolution.FullHd) is required — and on iOS this is the official sample's choice for better decode range — fetch the recommended settings first and then override only what you need:

var cameraSettings = BarcodeBatch.RecommendedCameraSettings;
cameraSettings.PreferredResolution = VideoResolution.FullHd;
this.camera.ApplySettingsAsync(cameraSettings);

BarcodeBatch.RecommendedCameraSettings is a static property, not a method. The Swift form recommendedCameraSettings is a class var — the .NET binding exposes it as a static property here.

Factory rename: nothing to change

BarcodeBatch.Create(context, settings) was the .NET factory in v6 (as BarcodeTracking.Create(context, settings)) and continues to be the factory in v7+. There is no rename from Create(...) to ForDataCaptureContext(...) — the .NET binding has always exposed Create. If the codebase already uses BarcodeTracking.Create(...), the only change is renaming BarcodeTracking → BarcodeBatch (covered above).

Frame disposal stays mandatory

IFrameData.Dispose() (called inside OnSessionUpdated to avoid a frozen / stuttering preview) is required in v6 too — no change. If the v6 code already disposes the frame in a finally block, leave that intact through the rename.

New v7 APIs (optional, mention only if asked)

• BarcodeBatchBasicOverlayStyle.Dot — an alternative to the default Frame style. Pass it to BarcodeBatchBasicOverlay.Create(barcodeBatch, dataCaptureView, BarcodeBatchBasicOverlayStyle.Dot).

---

Migration: 7 → 8

The 7→8 step for .NET iOS MatrixScan Batch is mostly mechanical. The factory methods (BarcodeBatch.Create(context, settings) and the overlay Create(...) overloads), the listener / event surface, the session API, and the tracked-barcode model are all unchanged. The one required action is adding explicit SDK initialization at app launch — without it, the app crashes on the first Scandit API call.

Explicit SDK initialization is now required

Scandit 8.0 removed the implicit container bootstrap that 6.x/7.x performed automatically. The app must now call ScanditCaptureCore.Initialize() and ScanditBarcodeCapture.Initialize() before any Scandit type is constructed.

Find the project's AppDelegate (a class registered with [Register("AppDelegate")], typically in AppDelegate.cs) and add the two Initialize() calls at the top of FinishedLaunching (before any window / root view controller creation):

using Scandit.DataCapture.Barcode;
using Scandit.DataCapture.Core;

[Export("application:didFinishLaunchingWithOptions:")]
public bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
{
    ScanditCaptureCore.Initialize();
    ScanditBarcodeCapture.Initialize();
    // ... existing launch code stays below
    return true;
}

Make sure these using directives are present:

using Scandit.DataCapture.Barcode;
using Scandit.DataCapture.Core;

If the project has no AppDelegate (e.g. it's a Mac Catalyst / SceneDelegate-only setup), add the calls to whichever launch hook fires first — but they must run before any DataCaptureContext.ForLicenseKey(...) / BarcodeBatch.Create(...) / DataCaptureView.Create(...) call.

Symptom if this step is skipped: instant launch crash at the first Scandit type construction, because the DI container has no registrations.

BarcodeBatchLicenseInfo introduced in 8.4

If the user wants to inspect which symbologies the active license allows, this is available in 8.4+:

// Hook IDataCaptureContextListener and wait for OnModeAdded before reading the property.
BarcodeBatchLicenseInfo? info = this.barcodeBatch.BarcodeBatchLicenseInfo;
ICollection<Symbology>? licensed = info?.LicensedSymbologies;

The property does not exist on dotnet.ios 8.0–8.3 — gate any usage on the installed SDK version.

No other breaking BarcodeBatch changes

BarcodeBatch.Create(context, settings), BarcodeBatchSettings.Create(), IBarcodeBatchListener.OnSessionUpdated(BarcodeBatch, BarcodeBatchSession, IFrameData), the SessionUpdated event, the BarcodeBatchSession properties (AddedTrackedBarcodes, UpdatedTrackedBarcodes, RemovedTrackedBarcodes, TrackedBarcodes), the DataCaptureView.Create(context, frame) iOS overload, and both overlays (BarcodeBatchBasicOverlay.Create(...), BarcodeBatchAdvancedOverlay.Create(...)) are all unchanged in v8 for .NET for iOS.

---

After applying changes

1. Restore NuGet packages (dotnet restore) and rebuild. Fix any remaining compile errors using the API reference (linked in SKILL.md). 2. Let the user know they can check the full list of SDK changes in the official migration guides:

• 6 → 7: https://docs.scandit.com/sdks/net/ios/migrate-6-to-7/
• 7 → 8: https://docs.scandit.com/sdks/net/ios/migrate-7-to-8/

3. Show the user a summary of only the changes actually made: which files were edited, which classes were renamed, and anything that required a judgment call (e.g., the using directive renames that the IDE may also auto-fix on save). Do not list APIs that were already correct or unchanged. 4. If compile errors persist after the changes above, fetch the BarcodeBatch API reference (https://docs.scandit.com/data-capture-sdk/dotnet.ios/barcode-capture/api.html) to find the correct API before guessing.

Third-Party Multi-Barcode Scanner → MatrixScan Batch Migration (.NET for iOS)

Before anything else

Read the existing code. Do not ask the user to describe what their scanner does. Identify:

• Which framework is in use (read the using directives and <PackageReference> lines).
• Which symbologies are enabled.
• How the project is collecting "all visible barcodes" — an AVCaptureMetadataOutput delegate that fires on every frame, a continuous ZXing.Net.Mobile scan loop that restarts itself after each result, a hand-rolled AVCaptureVideoDataOutput + Vision (VNDetectBarcodesRequest) pipeline, etc.
• What result-handling logic exists (deduplication on the string value, accumulation in a List/HashSet, filtering by symbology / prefix).
• What data models are defined.
• How the scanner UI is rendered (full-screen UIViewController with an AVCaptureVideoPreviewLayer, embedded scanner view, modal presentation).

Common third-party scanners abused for batch use in .NET iOS codebases:

• AVFoundation `AVCaptureMetadataOutput` — Apple's built-in barcode detector. Fires DidOutputMetadataObjects on the camera queue with an array of AVMetadataMachineReadableCodeObject per frame. Already multi-result per frame, but the developer typically rebuilds tracking / dedupe by hand.
• AVFoundation + Vision (`VNDetectBarcodesRequest`) — Vision-based detection running on AVCaptureVideoDataOutput frames. Multi-result; the developer assembles their own tracking layer.
• ZXing.Net.Mobile (ZXing.Mobile.MobileBarcodeScanner, ZXing.BarcodeFormat) — usually a continuous-scan loop that restarts itself after each result. Single-barcode by design; "batch" behavior is emergent from looping. Note: ZXing.Net.Mobile has been unmaintained on iOS for years and does not officially support modern net*-ios targets — moving to Scandit also lifts the dependency.
• ZXing.Net — pure decoder, often paired with a hand-written AVCaptureVideoDataOutput analyzer that runs BarcodeReader.Decode (or DecodeMultiple) on each pixel buffer.

MatrixScan Batch replaces all of the above: it owns the camera, runs the recognizer on every frame, tracks each barcode across frames (assigning a stable per-barcode tracking ID), and reports additions / updates / removals via IBarcodeBatchListener.OnSessionUpdated. There is no continuous-scan loop to re-trigger — the session updates fire on their own.

---

Remove

• The third-party <PackageReference> entries from the .csproj (e.g. ZXing.Net.Mobile, ZXing.Net.Mobile.Forms, ZXing.Net).
• All using ZXing.*; directives. Keep using AVFoundation; / using Vision; only if other parts of the controller still need them; otherwise remove.
• The AVCaptureSession, AVCaptureDevice, AVCaptureMetadataOutput (and its IAVCaptureMetadataOutputObjectsDelegate delegate), AVCaptureVideoDataOutput, AVCaptureVideoPreviewLayer, and any setup code that wires them together. Scandit's Camera and DataCaptureView replace this whole stack.
• Vision pipeline pieces: VNImageRequestHandler, VNDetectBarcodesRequest, the dispatch-queue boilerplate.
• The continuous-scan loop / frame analyzer (the while (...) / _ = StartScanAsync() re-trigger, the metadata-output delegate callback, the per-frame buffer-to-CVPixelBuffer conversion).
• Any UI code specific to the old scanner — manually-drawn highlight rectangles, custom viewfinder overlay layers, the AVCaptureVideoPreviewLayer resize handler. MatrixScan Batch's DataCaptureView + BarcodeBatchBasicOverlay (or BarcodeBatchAdvancedOverlay) replace all of it.

---

Integrate MatrixScan Batch

Follow references/integration.md. The key shape of the rewrite:

1. Replace the scanner's camera setup with the Scandit camera pipeline. Camera.GetDefaultCamera() → camera.ApplySettingsAsync(BarcodeBatch.RecommendedCameraSettings) → dataCaptureContext.SetFrameSourceAsync(camera). Drive on/off from ViewWillAppear / ViewWillDisappear via camera.SwitchToDesiredStateAsync(FrameSourceState.On / Off). 2. Replace the scanner's preview view with `DataCaptureView`. DataCaptureView.Create(dataCaptureContext, this.View!.Bounds) returns a UIView. Set AutoresizingMask = UIViewAutoresizing.FlexibleHeight | UIViewAutoresizing.FlexibleWidth, then this.View.AddSubview(dataCaptureView) and this.View.SendSubviewToBack(dataCaptureView). Remove the old AVCaptureVideoPreviewLayer / custom preview view from the layout. 3. Replace the scanner's symbology configuration with `BarcodeBatchSettings`. Use the symbology mapping table below. 4. Replace the scanner's per-result callback with `IBarcodeBatchListener.OnSessionUpdated` (or the `SessionUpdated` event). Use the result-pattern mapping table below. Wrap UI work in DispatchQueue.MainQueue.DispatchAsync(...) and always call `frameData.Dispose()` in a `finally` block. 5. Replace any manually-drawn highlight with `BarcodeBatchBasicOverlay`. BarcodeBatchBasicOverlay.Create(barcodeBatch, dataCaptureView) auto-adds itself to the view. Use BarcodeBatchBasicOverlayStyle.Frame (default) or Dot.

When configuring BarcodeBatchSettings, map symbologies from the old scanner using the table below. Do not guess or derive Scandit symbology names from the old library's names — they differ (e.g. AVFoundation's AVMetadataObjectType.QRCode and ZXing's QR_CODE both map to Symbology.Qr, not Symbology.QrCode).

Symbology mapping

AVFoundation has no UPC_A constant of its own — UPC-A is reported as EAN13Code with a leading 0. The Scandit equivalent is Symbology.Ean13Upca (which decodes both EAN-13 and UPC-A natively).

If you encounter a symbology not in this table, fetch the BarcodeBatch API reference for the correct Symbology enum value before writing the code.

Result-pattern mapping

---

Preserve

• Custom data models — keep as-is.
• Result accumulation and deduplication logic — move it into OnSessionUpdated (or the SessionUpdated event handler). Iterate session.AddedTrackedBarcodes and append to the existing collection. Wrap UI updates in `DispatchQueue.MainQueue.DispatchAsync(() => { … })` because `OnSessionUpdated` runs on a background recognition queue. Copy the data you need out of the session before scheduling the UI dispatch — the session is only safe to access from inside the callback. Always end the callback with `frameData.Dispose()` in a `finally` block (or the preview freezes / stutters).
• Any downstream business logic triggered on a new barcode (network lookup, database insert).
• Validation / reject behavior — if the old scanner had a "is this code valid?" check, port it as a filter when iterating AddedTrackedBarcodes inside OnSessionUpdated.

---

Putting it all together

A typical "AVCaptureMetadataOutput loop replaced with MatrixScan Batch" shape:

using System.Collections.Generic;
using System.Linq;
using CoreFoundation;
using UIKit;

using Scandit.DataCapture.Barcode.Batch.Capture;
using Scandit.DataCapture.Barcode.Batch.Data;
using Scandit.DataCapture.Barcode.Batch.UI.Overlay;
using Scandit.DataCapture.Barcode.Data;
using Scandit.DataCapture.Core.Capture;
using Scandit.DataCapture.Core.Data;
using Scandit.DataCapture.Core.Source;
using Scandit.DataCapture.Core.UI;

public partial class ScannerViewController : UIViewController, IBarcodeBatchListener
{
    public const string SCANDIT_LICENSE_KEY = "-- ENTER YOUR SCANDIT LICENSE KEY HERE --";

    private DataCaptureContext dataCaptureContext = null!;
    private BarcodeBatch barcodeBatch = null!;
    private Camera? camera;

    private readonly List<ScannedBarcode> scannedBarcodes = new();
    private readonly HashSet<int> seenTrackingIds = new();

    public ScannerViewController(IntPtr handle) : base(handle) { }

    public override void ViewDidLoad()
    {
        base.ViewDidLoad();
        this.InitializeAndStartBatchScanning();
    }

    public override void ViewWillAppear(bool animated)
    {
        base.ViewWillAppear(animated);
        this.barcodeBatch.Enabled = true;
        this.camera?.SwitchToDesiredStateAsync(FrameSourceState.On);
    }

    public override void ViewWillDisappear(bool animated)
    {
        base.ViewWillDisappear(animated);
        this.barcodeBatch.Enabled = false;
        this.camera?.SwitchToDesiredStateAsync(FrameSourceState.Off);
    }

    private void InitializeAndStartBatchScanning()
    {
        this.dataCaptureContext = DataCaptureContext.ForLicenseKey(SCANDIT_LICENSE_KEY);

        this.camera = Camera.GetDefaultCamera();
        if (this.camera != null)
        {
            var cameraSettings = BarcodeBatch.RecommendedCameraSettings;
            cameraSettings.PreferredResolution = VideoResolution.FullHd;
            this.camera.ApplySettingsAsync(cameraSettings);
            this.dataCaptureContext.SetFrameSourceAsync(this.camera);
        }

        BarcodeBatchSettings settings = BarcodeBatchSettings.Create();
        settings.EnableSymbologies(new HashSet<Symbology>
        {
            Symbology.Ean13Upca,   // from AVMetadataObjectType.EAN13Code / ZXing EAN_13
            Symbology.Code128,     // from AVMetadataObjectType.Code128Code / ZXing CODE_128
            Symbology.Qr,          // from AVMetadataObjectType.QRCode    / ZXing QR_CODE
        });

        this.barcodeBatch = BarcodeBatch.Create(this.dataCaptureContext, settings);
        this.barcodeBatch.AddListener(this);

        var dataCaptureView = DataCaptureView.Create(this.dataCaptureContext, this.View!.Bounds);
        UIView platformView = dataCaptureView;
        platformView.AutoresizingMask = UIViewAutoresizing.FlexibleHeight |
                                        UIViewAutoresizing.FlexibleWidth;
        this.View.AddSubview(dataCaptureView);
        this.View.SendSubviewToBack(dataCaptureView);

        BarcodeBatchBasicOverlay.Create(this.barcodeBatch, dataCaptureView);
    }

    public void OnSessionUpdated(
        BarcodeBatch barcodeBatch,
        BarcodeBatchSession session,
        IFrameData frameData)
    {
        try
        {
            // Same dedupe-and-accumulate as the old AVFoundation / ZXing loop,
            // but driven by per-frame deltas.
            var newScans = session.AddedTrackedBarcodes
                .Where(tb => this.seenTrackingIds.Add(tb.Identifier))
                .Select(tb => new ScannedBarcode(
                    tb.Barcode.Data ?? string.Empty,
                    tb.Barcode.Symbology.ToString()))
                .ToList();

            if (newScans.Count == 0) return;

            DispatchQueue.MainQueue.DispatchAsync(() =>
            {
                this.scannedBarcodes.AddRange(newScans);
                // update UI here
            });
        }
        finally
        {
            // Mandatory on iOS to avoid a frozen / stuttering preview.
            frameData.Dispose();
        }
    }

    public void OnObservationStarted(BarcodeBatch barcodeBatch) { }
    public void OnObservationStopped(BarcodeBatch barcodeBatch) { }
}

---

When done, show only what changed. Do not list APIs that were unchanged. Include the setup checklist from references/integration.md so the user knows which NuGet packages, Info.plist entries (NSCameraUsageDescription), SupportedOSPlatformVersion, and SDK-8.0+ AppDelegate.FinishedLaunching initialization to add.