barsa-develop-components 2.2.2 → 2.2.4

package/esm2022/lib/barcode.service.mjs

@@ -0,0 +1,330 @@
+import { DecodeHintType, BarcodeFormat } from '@zxing/library';
+import { ChecksumException, FormatException, NotFoundException } from '@zxing/library';
+import { BrowserCodeReader, BrowserMultiFormatReader } from '@zxing/browser';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { filter, map, shareReplay } from 'rxjs/operators';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "barsa-novin-ray-core";
+/**
+ * Based on zxing-typescript BrowserCodeReader
+ */
+export class BrowserMultiFormatContinuousReader extends BrowserMultiFormatReader {
+    /**
+     * Returns the code reader scanner controls.
+     */
+    getScannerControls() {
+        if (!this.scannerControls) {
+            throw new Error('No scanning is running at the time.');
+        }
+        return this.scannerControls;
+    }
+    /**
+     * Starts the decoding from the current or a new video element.
+     *
+     * @param deviceId The device's to be used Id
+     * @param previewEl A new video element
+     */
+    async scanFromDeviceObservable(deviceId, previewEl) {
+        const scan$ = new BehaviorSubject({});
+        let ctrls;
+        try {
+            ctrls = await this.decodeFromVideoDevice(deviceId, previewEl, (result, error) => {
+                if (!error) {
+                    scan$.next({ result });
+                    return;
+                }
+                console.error(error);
+                const errorName = error.name;
+                // stream cannot stop on fails.
+                if (
+                // scan Failure - found nothing, no error
+                errorName === NotFoundException.name ||
+                    // scan Error - found the QR but got error on decoding
+                    errorName === ChecksumException.name ||
+                    errorName === FormatException.name ||
+                    error.message.includes('No MultiFormat Readers were able to detect the code.')) {
+                    scan$.next({ error });
+                    return;
+                }
+                // probably fatal error
+                scan$.error(error);
+                this.scannerControls?.stop();
+                this.scannerControls = undefined;
+                return;
+            });
+            this.scannerControls = {
+                ...ctrls,
+                stop() {
+                    ctrls.stop();
+                    scan$.complete();
+                }
+            };
+        }
+        catch (e) {
+            scan$.error(e);
+            this.scannerControls?.stop();
+            this.scannerControls = undefined;
+        }
+        return scan$.asObservable();
+    }
+}
+export class UserMediaBaseService {
+    /**
+     *
+     */
+    constructor(_logService) {
+        this._logService = _logService;
+        this.hasNavigator = false;
+        this.isMediaDevicesSupported = false;
+        this._camerasSource = new BehaviorSubject([]);
+        this.cameras$ = this._camerasSource
+            .asObservable()
+            .pipe(shareReplay(1))
+            .pipe(filter((items) => items && items.length > 0));
+        this._permissionResponse = new Subject();
+        this.permissionResponse$ = this._permissionResponse.asObservable();
+        this._hasDevicesSource = new BehaviorSubject(false);
+        this.hasDevices$ = this._hasDevicesSource.asObservable().pipe(shareReplay(1));
+        this._permissionSource = new BehaviorSubject(false);
+        this.permission$ = this._permissionSource.asObservable().pipe();
+        this._camerasNotFoundSource = new Subject();
+        this.camerasNotFound$ = this._camerasNotFoundSource.asObservable().pipe(shareReplay(1));
+        this.hasNavigator = typeof navigator !== 'undefined';
+        this.isMediaDevicesSupported = this.hasNavigator && !!navigator.mediaDevices;
+    }
+    async updateVideoInputDevices() {
+        // permissions aren't needed to get devices, but to access them and their info
+        const devices = (await BrowserCodeReader.listVideoInputDevices()) || [];
+        const hasDevices = devices && devices.length > 0;
+        // stores discovered devices and updates information
+        this._hasDevicesSource.next(hasDevices);
+        this._camerasSource.next([...devices]);
+        if (!hasDevices) {
+            const err = {
+                code: DOMException.NOT_FOUND_ERR,
+                message: 'Device not found.'
+            };
+            this._camerasNotFoundSource.next(err);
+        }
+        return devices;
+    }
+    /**
+     * Gets and registers all cammeras.
+     */
+    async askForPermission() {
+        if (!this.hasNavigator) {
+            this._logService.error('user media', `Can't ask permission, navigator is not present.`);
+            this._setPermission(false);
+        }
+        if (!this.isMediaDevicesSupported) {
+            this._logService.error('user media', `Can't get user media, this is not supported.`);
+            this._setPermission(false);
+        }
+        let stream;
+        let permission = false;
+        try {
+            // Will try to ask for permission
+            stream = await this._getAnyVideoDevice();
+            permission = !!stream;
+        }
+        catch (err) {
+            this._handlePermissionException(err);
+        }
+        finally {
+            this.terminateStream(stream);
+        }
+        this._setPermission(permission);
+        return permission;
+    }
+    terminateStream(stream) {
+        if (stream) {
+            stream.getTracks().forEach((t) => t.stop());
+        }
+        stream = undefined;
+    }
+    _setPermission(permission) {
+        this._permissionSource.next(permission);
+    }
+    _getAnyVideoDevice() {
+        return navigator.mediaDevices.getUserMedia({ video: true });
+    }
+    _handlePermissionException(err) {
+        console.error('user media', 'Error when asking for permission.', err);
+        let permission = false;
+        switch (err.name) {
+            // usually caused by not secure origins
+            case 'NotSupportedError':
+                this._logService.warn('user media', err.message);
+                // could not claim
+                permission = false;
+                // can't check devices
+                this._hasDevicesSource.next(false);
+                break;
+            // user denied permission
+            case 'NotAllowedError':
+                this._logService.warn('user media', err.message);
+                // claimed and denied permission
+                permission = false;
+                // this means that input devices exists
+                this._hasDevicesSource.next(true);
+                break;
+            // the device has no attached input devices
+            case 'NotFoundError':
+                this._logService.warn('user media', err.message);
+                // no permissions claimed
+                permission = false;
+                // because there was no devices
+                this._hasDevicesSource.next(false);
+                // tells the listener about the error
+                this._camerasNotFoundSource.next(err);
+                break;
+            case 'NotReadableError':
+                this._logService.warn('user media', `Couldn't read the device(s)'s stream, it's probably in use by another app.`);
+                // no permissions claimed
+                permission = false;
+                // there are devices, which I couldn't use
+                this._hasDevicesSource.next(false);
+                // tells the listener about the error
+                this._camerasNotFoundSource.next(err);
+                break;
+            default:
+                this._logService.warn('user media', 'I was not able to define if I have permissions for camera or not.', err);
+                // unknown
+                permission = false;
+                // this.hasDevices.next(undefined;
+                break;
+        }
+        this._setPermission(permission);
+        // tells the listener about the error
+        this._permissionResponse.next(err);
+        return permission;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserMediaBaseService, deps: [{ token: i1.LogService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserMediaBaseService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserMediaBaseService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.LogService }] });
+export class WebBarcodeService {
+    constructor(userMediaService) {
+        this.userMediaService = userMediaService;
+        this._device = undefined;
+        this._codeReader = undefined;
+        this._hints = new Map();
+        this._scanErrorSource = new Subject();
+        this._scanFailureSource = new Subject();
+        this._scanCompleteSource = new Subject();
+        this._scanSuccessSource = new Subject();
+        this._options = {
+            delayBetweenScanAttempts: 50,
+            delayBetweenScanSuccess: 500
+        };
+        this.scanError$ = this._scanErrorSource.asObservable();
+        this.scanFailure$ = this._scanFailureSource.asObservable();
+        this.scanComplete$ = this._scanCompleteSource.asObservable();
+        this.scanSuccess$ = this._scanSuccessSource.asObservable().pipe(map((c) => c.getText()));
+    }
+    startScan(device, videoEl, options = this._options) {
+        // instantly stops the scan before changing devices
+        this.scanStop();
+        // correctly sets the new (or none) device
+        this._device = device || undefined;
+        this._videoEl = videoEl;
+        this._options = options;
+        if (!this._device) {
+            // cleans the video because user removed the device
+            BrowserCodeReader.cleanVideoSource(videoEl);
+        }
+        if (this._scanSubscription) {
+            throw new Error('There is already a scan proccess running.');
+        }
+        if (!this._device) {
+            throw new Error('No device defined, cannot start scan, please define a device.');
+        }
+        // if enabled, starts scanning
+        if (device) {
+            this.scanFromDevice(device.deviceId);
+        }
+    }
+    setFormat(input) {
+        if (typeof input === 'string') {
+            throw new Error('Invalid formats, make sure the [formats] input is a binding.');
+        }
+        // formats may be set from html template as BarcodeFormat or string array
+        const formats = input.map((f) => this.getBarcodeFormatOrFail(f));
+        const hints = this._hints;
+        // updates the hints
+        hints.set(DecodeHintType.POSSIBLE_FORMATS, formats);
+        // handles updating the codeReader
+        this._hints = hints;
+    }
+    scanStop() {
+        if (this._scanSubscription) {
+            this._codeReader?.getScannerControls().stop();
+            this._scanSubscription?.unsubscribe();
+            this._scanSubscription = undefined;
+        }
+        // this.torchCompatible.next(false);
+    }
+    destroy() {
+        // @note apenas necessario por enquanto causa da Torch
+        this.scanStop();
+        this._codeReader = undefined;
+        this._device = undefined;
+    }
+    getBarcodeFormatOrFail(format) {
+        return typeof format === 'string' ? BarcodeFormat[format.trim().toUpperCase()] : format;
+    }
+    async scanFromDevice(deviceId) {
+        const videoElement = this._videoEl;
+        const codeReader = this.getCodeReader();
+        const scanStream = await codeReader.scanFromDeviceObservable(deviceId, videoElement);
+        if (!scanStream) {
+            throw new Error('Undefined decoding stream, aborting.');
+        }
+        const next = (x) => this._onDecodeResult(x.result, x.error);
+        const error = (err) => this._onDecodeError(err);
+        const complete = () => { };
+        this._scanSubscription = scanStream.subscribe(next, error, complete);
+        if (this._scanSubscription.closed) {
+            return;
+        }
+        // const controls = codeReader.getScannerControls();
+        // const hasTorchControl = typeof controls.switchTorch !== 'undefined';
+        // this.torchCompatible.next(hasTorchControl);
+    }
+    /**
+     * Handles decode errors.
+     */
+    _onDecodeError(err) {
+        this._scanErrorSource.next(err);
+        // this.reset();
+    }
+    /**
+     * Handles decode results.
+     */
+    _onDecodeResult(result, error) {
+        if (result) {
+            this._scanSuccessSource.next(result);
+        }
+        else {
+            this._scanFailureSource.next(error);
+        }
+        if (result) {
+            this._scanCompleteSource.next(result);
+        }
+    }
+    getCodeReader() {
+        if (!this._codeReader) {
+            this._codeReader = new BrowserMultiFormatContinuousReader(this._hints, this._options);
+        }
+        return this._codeReader;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WebBarcodeService, deps: [{ token: UserMediaBaseService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WebBarcodeService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WebBarcodeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: UserMediaBaseService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"barcode.service.js","sourceRoot":"","sources":["../../../../projects/barsa-develop-components/src/lib/barcode.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Result, Exception, DecodeHintType, BarcodeFormat } from '@zxing/library';\r\nimport { ChecksumException, FormatException, NotFoundException } from '@zxing/library';\r\nimport { BrowserCodeReader, BrowserMultiFormatReader, IScannerControls } from '@zxing/browser';\r\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\r\nimport { LogService } from 'barsa-novin-ray-core';\r\nimport { filter, map, shareReplay } from 'rxjs/operators';\r\nimport { Injectable } from '@angular/core';\r\n\r\nexport interface ResultAndError {\r\n    result?: Result;\r\n    error?: Exception;\r\n}\r\n\r\n/**\r\n * Based on zxing-typescript BrowserCodeReader\r\n */\r\nexport class BrowserMultiFormatContinuousReader extends BrowserMultiFormatReader {\r\n    /**\r\n     * Allows to call scanner controls API while scanning.\r\n     * Will be undefined if no scanning is runnig.\r\n     */\r\n    protected scannerControls: IScannerControls | undefined;\r\n\r\n    /**\r\n     * Returns the code reader scanner controls.\r\n     */\r\n    public getScannerControls(): IScannerControls {\r\n        if (!this.scannerControls) {\r\n            throw new Error('No scanning is running at the time.');\r\n        }\r\n        return this.scannerControls;\r\n    }\r\n\r\n    /**\r\n     * Starts the decoding from the current or a new video element.\r\n     *\r\n     * @param deviceId The device's to be used Id\r\n     * @param previewEl A new video element\r\n     */\r\n    public async scanFromDeviceObservable(\r\n        deviceId?: string,\r\n        previewEl?: HTMLVideoElement\r\n    ): Promise<Observable<ResultAndError>> {\r\n        const scan$ = new BehaviorSubject<ResultAndError>({});\r\n        let ctrls;\r\n\r\n        try {\r\n            ctrls = await this.decodeFromVideoDevice(deviceId, previewEl, (result, error) => {\r\n                if (!error) {\r\n                    scan$.next({ result });\r\n                    return;\r\n                }\r\n                console.error(error);\r\n                const errorName = error.name;\r\n\r\n                // stream cannot stop on fails.\r\n                if (\r\n                    // scan Failure - found nothing, no error\r\n                    errorName === NotFoundException.name ||\r\n                    // scan Error - found the QR but got error on decoding\r\n                    errorName === ChecksumException.name ||\r\n                    errorName === FormatException.name ||\r\n                    error.message.includes('No MultiFormat Readers were able to detect the code.')\r\n                ) {\r\n                    scan$.next({ error });\r\n                    return;\r\n                }\r\n\r\n                // probably fatal error\r\n                scan$.error(error);\r\n                this.scannerControls?.stop();\r\n                this.scannerControls = undefined;\r\n                return;\r\n            });\r\n\r\n            this.scannerControls = {\r\n                ...ctrls,\r\n                stop(): void {\r\n                    ctrls.stop();\r\n                    scan$.complete();\r\n                }\r\n            };\r\n        } catch (e) {\r\n            scan$.error(e);\r\n            this.scannerControls?.stop();\r\n            this.scannerControls = undefined;\r\n        }\r\n\r\n        return scan$.asObservable();\r\n    }\r\n}\r\n@Injectable()\r\nexport class UserMediaBaseService {\r\n    hasNavigator = false;\r\n    isMediaDevicesSupported = false;\r\n\r\n    _camerasSource = new BehaviorSubject<MediaDeviceInfo[]>([]);\r\n    cameras$ = this._camerasSource\r\n        .asObservable()\r\n        .pipe(shareReplay(1))\r\n        .pipe(filter((items) => items && items.length > 0));\r\n\r\n    _permissionResponse = new Subject<DOMException>();\r\n    permissionResponse$ = this._permissionResponse.asObservable();\r\n\r\n    _hasDevicesSource = new BehaviorSubject<boolean>(false);\r\n    hasDevices$ = this._hasDevicesSource.asObservable().pipe(shareReplay(1));\r\n\r\n    _permissionSource = new BehaviorSubject<boolean>(false);\r\n    permission$ = this._permissionSource.asObservable().pipe();\r\n\r\n    _camerasNotFoundSource = new Subject<DOMException>();\r\n    camerasNotFound$ = this._camerasNotFoundSource.asObservable().pipe(shareReplay(1));\r\n\r\n    /**\r\n     *\r\n     */\r\n    constructor(private _logService: LogService) {\r\n        this.hasNavigator = typeof navigator !== 'undefined';\r\n        this.isMediaDevicesSupported = this.hasNavigator && !!navigator.mediaDevices;\r\n    }\r\n\r\n    async updateVideoInputDevices(): Promise<MediaDeviceInfo[]> {\r\n        // permissions aren't needed to get devices, but to access them and their info\r\n        const devices = (await BrowserCodeReader.listVideoInputDevices()) || [];\r\n        const hasDevices = devices && devices.length > 0;\r\n\r\n        // stores discovered devices and updates information\r\n        this._hasDevicesSource.next(hasDevices);\r\n        this._camerasSource.next([...devices]);\r\n\r\n        if (!hasDevices) {\r\n            const err = {\r\n                code: DOMException.NOT_FOUND_ERR,\r\n                message: 'Device not found.'\r\n            };\r\n            this._camerasNotFoundSource.next(err as DOMException);\r\n        }\r\n\r\n        return devices;\r\n    }\r\n\r\n    /**\r\n     * Gets and registers all cammeras.\r\n     */\r\n    async askForPermission(): Promise<boolean> {\r\n        if (!this.hasNavigator) {\r\n            this._logService.error('user media', `Can't ask permission, navigator is not present.`);\r\n            this._setPermission(false);\r\n        }\r\n\r\n        if (!this.isMediaDevicesSupported) {\r\n            this._logService.error('user media', `Can't get user media, this is not supported.`);\r\n            this._setPermission(false);\r\n        }\r\n\r\n        let stream: MediaStream | undefined;\r\n        let permission = false;\r\n\r\n        try {\r\n            // Will try to ask for permission\r\n            stream = await this._getAnyVideoDevice();\r\n            permission = !!stream;\r\n        } catch (err) {\r\n            this._handlePermissionException(err as DOMException);\r\n        } finally {\r\n            this.terminateStream(stream);\r\n        }\r\n\r\n        this._setPermission(permission);\r\n        return permission;\r\n    }\r\n    protected terminateStream(stream: MediaStream | undefined): void {\r\n        if (stream) {\r\n            stream.getTracks().forEach((t) => t.stop());\r\n        }\r\n\r\n        stream = undefined;\r\n    }\r\n    protected _setPermission(permission: boolean): void {\r\n        this._permissionSource.next(permission);\r\n    }\r\n    protected _getAnyVideoDevice(): Promise<MediaStream> {\r\n        return navigator.mediaDevices.getUserMedia({ video: true });\r\n    }\r\n    protected _handlePermissionException(err: DOMException): boolean {\r\n        console.error('user media', 'Error when asking for permission.', err);\r\n        let permission = false;\r\n\r\n        switch (err.name) {\r\n            // usually caused by not secure origins\r\n            case 'NotSupportedError':\r\n                this._logService.warn('user media', err.message);\r\n                // could not claim\r\n                permission = false;\r\n                // can't check devices\r\n                this._hasDevicesSource.next(false);\r\n                break;\r\n\r\n            // user denied permission\r\n            case 'NotAllowedError':\r\n                this._logService.warn('user media', err.message);\r\n                // claimed and denied permission\r\n                permission = false;\r\n                // this means that input devices exists\r\n                this._hasDevicesSource.next(true);\r\n                break;\r\n\r\n            // the device has no attached input devices\r\n            case 'NotFoundError':\r\n                this._logService.warn('user media', err.message);\r\n                // no permissions claimed\r\n                permission = false;\r\n                // because there was no devices\r\n                this._hasDevicesSource.next(false);\r\n                // tells the listener about the error\r\n                this._camerasNotFoundSource.next(err);\r\n                break;\r\n\r\n            case 'NotReadableError':\r\n                this._logService.warn(\r\n                    'user media',\r\n                    `Couldn't read the device(s)'s stream, it's probably in use by another app.`\r\n                );\r\n                // no permissions claimed\r\n                permission = false;\r\n                // there are devices, which I couldn't use\r\n                this._hasDevicesSource.next(false);\r\n                // tells the listener about the error\r\n                this._camerasNotFoundSource.next(err);\r\n                break;\r\n\r\n            default:\r\n                this._logService.warn(\r\n                    'user media',\r\n                    'I was not able to define if I have permissions for camera or not.',\r\n                    err\r\n                );\r\n                // unknown\r\n                permission = false;\r\n                // this.hasDevices.next(undefined;\r\n                break;\r\n        }\r\n\r\n        this._setPermission(permission);\r\n\r\n        // tells the listener about the error\r\n        this._permissionResponse.next(err);\r\n\r\n        return permission;\r\n    }\r\n}\r\n@Injectable()\r\nexport class WebBarcodeService {\r\n    scanError$: Observable<Error>;\r\n    scanFailure$: Observable<Error>;\r\n    scanComplete$: Observable<Result>;\r\n    scanSuccess$: Observable<string>;\r\n\r\n    private _device: MediaDeviceInfo | undefined = undefined;\r\n    private _videoEl: HTMLVideoElement;\r\n    private _codeReader: BrowserMultiFormatContinuousReader | undefined = undefined;\r\n    private _hints: Map<DecodeHintType, any> = new Map<DecodeHintType, any>();\r\n    private _scanErrorSource = new Subject<Error>();\r\n    private _scanFailureSource = new Subject<Error>();\r\n    private _scanSubscription: any;\r\n    private _scanCompleteSource = new Subject<Result>();\r\n    private _scanSuccessSource = new Subject<Result>();\r\n    private _options: {\r\n        delayBetweenScanAttempts: number;\r\n        delayBetweenScanSuccess: number;\r\n    } = {\r\n        delayBetweenScanAttempts: 50,\r\n        delayBetweenScanSuccess: 500\r\n    };\r\n\r\n    constructor(public userMediaService: UserMediaBaseService) {\r\n        this.scanError$ = this._scanErrorSource.asObservable();\r\n        this.scanFailure$ = this._scanFailureSource.asObservable();\r\n        this.scanComplete$ = this._scanCompleteSource.asObservable();\r\n        this.scanSuccess$ = this._scanSuccessSource.asObservable().pipe(map((c) => c.getText()));\r\n    }\r\n\r\n    public startScan(device: MediaDeviceInfo, videoEl: HTMLVideoElement, options = this._options): void {\r\n        // instantly stops the scan before changing devices\r\n        this.scanStop();\r\n\r\n        // correctly sets the new (or none) device\r\n        this._device = device || undefined;\r\n        this._videoEl = videoEl;\r\n        this._options = options;\r\n        if (!this._device) {\r\n            // cleans the video because user removed the device\r\n            BrowserCodeReader.cleanVideoSource(videoEl);\r\n        }\r\n        if (this._scanSubscription) {\r\n            throw new Error('There is already a scan proccess running.');\r\n        }\r\n\r\n        if (!this._device) {\r\n            throw new Error('No device defined, cannot start scan, please define a device.');\r\n        }\r\n\r\n        // if enabled, starts scanning\r\n        if (device) {\r\n            this.scanFromDevice(device.deviceId);\r\n        }\r\n    }\r\n    public setFormat(input: BarcodeFormat[]): void {\r\n        if (typeof input === 'string') {\r\n            throw new Error('Invalid formats, make sure the [formats] input is a binding.');\r\n        }\r\n\r\n        // formats may be set from html template as BarcodeFormat or string array\r\n        const formats = input.map((f) => this.getBarcodeFormatOrFail(f));\r\n\r\n        const hints = this._hints;\r\n\r\n        // updates the hints\r\n        hints.set(DecodeHintType.POSSIBLE_FORMATS, formats);\r\n\r\n        // handles updating the codeReader\r\n        this._hints = hints;\r\n    }\r\n    public scanStop(): void {\r\n        if (this._scanSubscription) {\r\n            this._codeReader?.getScannerControls().stop();\r\n            this._scanSubscription?.unsubscribe();\r\n            this._scanSubscription = undefined;\r\n        }\r\n        // this.torchCompatible.next(false);\r\n    }\r\n\r\n    public destroy(): void {\r\n        // @note apenas necessario por enquanto causa da Torch\r\n        this.scanStop();\r\n        this._codeReader = undefined;\r\n        this._device = undefined;\r\n    }\r\n\r\n    private getBarcodeFormatOrFail(format: string | BarcodeFormat): BarcodeFormat {\r\n        return typeof format === 'string' ? BarcodeFormat[format.trim().toUpperCase()] : format;\r\n    }\r\n    private async scanFromDevice(deviceId: string): Promise<void> {\r\n        const videoElement = this._videoEl;\r\n\r\n        const codeReader = this.getCodeReader();\r\n\r\n        const scanStream = await codeReader.scanFromDeviceObservable(deviceId, videoElement);\r\n\r\n        if (!scanStream) {\r\n            throw new Error('Undefined decoding stream, aborting.');\r\n        }\r\n\r\n        const next = (x: ResultAndError): void => this._onDecodeResult(x.result, x.error);\r\n        const error = (err: any): void => this._onDecodeError(err);\r\n        const complete = (): void => {};\r\n\r\n        this._scanSubscription = scanStream.subscribe(next, error, complete);\r\n\r\n        if (this._scanSubscription.closed) {\r\n            return;\r\n        }\r\n\r\n        // const controls = codeReader.getScannerControls();\r\n        // const hasTorchControl = typeof controls.switchTorch !== 'undefined';\r\n\r\n        // this.torchCompatible.next(hasTorchControl);\r\n    }\r\n    /**\r\n     * Handles decode errors.\r\n     */\r\n    private _onDecodeError(err: any): void {\r\n        this._scanErrorSource.next(err);\r\n        // this.reset();\r\n    }\r\n    /**\r\n     * Handles decode results.\r\n     */\r\n    private _onDecodeResult(result: Result | undefined, error: Exception | undefined): void {\r\n        if (result) {\r\n            this._scanSuccessSource.next(result);\r\n        } else {\r\n            this._scanFailureSource.next(error as Error);\r\n        }\r\n        if (result) {\r\n            this._scanCompleteSource.next(result);\r\n        }\r\n    }\r\n    private getCodeReader(): BrowserMultiFormatContinuousReader {\r\n        if (!this._codeReader) {\r\n            this._codeReader = new BrowserMultiFormatContinuousReader(this._hints, this._options);\r\n        }\r\n\r\n        return this._codeReader;\r\n    }\r\n}\r\n"]}