Scan Multiple Barcodes (Legacy)

Single Scan vs. Continuous Scan

singleScanner.beginCapture(scanningOptions)
    .then((scannedBarcode) => 
        this.processScannedBarcode(scannedBarcode)

    )
    .catch((error) => {
        console.error(error);

    })
    .finally(() => {
        singleScanner.endCapture();
    });

sessionScanner.beginCapture(scanningOptions)
    .then((scannedBarcode) =>
        this.processScannedBarcode(scannedBarcode)
        this.continueScanning();
    )
    .catch((error) => {
        console.error(error);
        sessionScanner.endCapture();
    });

Continue a Scanning Session

continueScanning() {
    this.sessionScanner.resumeCapture()
    .then((scannedBarcode) => {
        this.processScannedBarcode(scannedBarcode);
        this.continueScanning();
    })
    .catch((error) => {
        this.processError(error);
        this.sessionScanner.endCapture();
    });
}

This code should look familiar; it’s nearly identical to the earlier beginCapture() example for continuous scanning. There‘s only one difference: continueScanning() creates a promise chain by calling sessionScanner.resumeCapture(), while the earlier example called sessionScanner.beginCapture(). It might be obvious, but you only call beginCapture() once, at the beginning of a scanning cycle.

The promise chain in continueScanning() ends the same two ways, with one important difference. While the code is the same, after a successful scan it continues the scanning cycle by calling itself, creating a recursive loop that continues the scanning cycle until the user clicks Cancel, or there’s an error.

Whoops. Didn’t mean to scare you with that word, recursive. Yes, continueScanning() ends by calling itself, which makes it a recursive function. But this recursion is pretty simple—it’s just a loop, an event loop of sorts. The loop handles scan-something events (in the then() block) until a user-clicked-Cancel event comes along (in the catch() block), and then it ends. It might take a minute, but you can wrap your head around it.

The code duplication between the beginCapture() and resumeCapture() promise chains is unfortunate, but unavoidable. Move as much processing code, such as the handling of a scanned barcode, into functions you can call from both chains. In the example here, processScannedBarcode() is a function that both promise chains use to handle a successful scan. See BarcodeScanner Example—Continuous Scanning (Legacy) for the complete sample, which includes that function’s implementation.

End Capture for Continuous Scanning

In a continuous scanning session, the user scans items repeatedly until they’re out of items. Then they click the Cancel button to end the session. In code, BarcodeScanner handles cancellation by rejecting the promise, and returning a BarcodeScannerError to signal that the user canceled scanning. See BarcodeScanner Example—Continuous Scanning (Legacy) for how to distinguish between the user clicking Cancel and an actual error.

Importantly, clicking the Cancel button is the only way to end a continuous scanning session. This is in contrast to a single scan session, which can end with either a successful scan or the Cancel button.

Because continuous scanning always ends with the Cancel button, and thus a BarcodeScannerError, we can call endCapture() in the error handling catch() block.

However, because a single scan might not end in a BarcodeScannerError, the catch() block might never execute. So for a single scan, we put endCapture() in the finally() block, to make sure that, success or failure, it always gets called.