scandit-sdk

import { ListenerFn } from "eventemitter3"; import { Camera } from "../camera"; import { CameraSettings } from "../cameraSettings"; import { Parser } from "../parser"; import { Scanner } from "../scanner"; import { ScanResult } from "../scanResult"; import { ScanSettings } from "../scanSettings"; import { SearchArea } from "../searchArea"; import { SingleImageModeSettings } from "../singleImageModeSettings"; /** * @hidden */ declare type EventName = "ready" | "submitFrame" | "processFrame" | "scan" | "scanError" | "cameraAccessError"; /** * A barcode picker element used to get and show camera input and perform scanning operations. * * The barcode picker will automatically fit and scale inside the given *originElement*. * * Each barcode picker internally contains a [[Scanner]] object with its own WebWorker thread running a * separate copy of the external Scandit Data Capture library. To optimize loading times and performance it's * recommended to reuse the same picker and to already create the picker in advance (hidden) and just * display it when needed whenever possible. * * As the loading of the external Scandit Data Capture library can take some time, the picker always starts inactive * (but showing GUI and video) and then activates, if not paused, as soon as the library is ready to scan. * The [[on]] method targeting the [[ready]] event can be used to set up a listener function to be called when the * library is loaded. The picker will be ready to start scanning when the library is fully loaded. * * By default the external Scandit Data Capture library is preloaded in order to reduce the initialization time as much * as possible. * * The picker can also operate in Single Image Mode: letting the user click/tap to take a single image to be scanned * via the camera (mobile) or a file select dialog (desktop). This is provided automatically as fallback by * default when the OS/browser only supports part of the needed features and cannot provide direct access to the camera * for video streaming and continuous scanning, or can also be forced on/off. This behaviour can be set up on creation * via the *singleImageModeSettings* option. Note that in this mode some of the functions provided by the picker will * have no effect. * * By default an alert is shown if an internal error during scanning is encountered which prevents the scanning * procedure from continuing when running on a local IP address. As this uses the built-in [[scanError]] event * functionality, if unwanted it can be disabled by calling [[removeAllListeners]] on the BarcodePicker * instance (right after creation). * * In accordance with our license terms, the Scandit logo displayed in the bottom right corner of the barcode picker * must be displayed and cannot be hidden by any method. Workarounds are not allowed. */ export declare class BarcodePicker { private readonly cameraManager; private readonly gui; private readonly eventEmitter; private readonly scanner; private readonly beepSound; private readonly vibrateFunction?; private readonly scannerReadyEventListener; private playSoundOnScan; private vibrateOnScan; private scanningPaused; private latestVideoTimeProcessed; private destroyed; private isReadyToWork; private cameraAccess; private targetScanningFPS; private averageProcessingTime; private externalImageData; private internalImageData?; private constructor(); /** * Fired when the external Scandit Data Capture library has been loaded and the barcode picker can thus start to scan * barcodes or texts. * * @asMemberOf BarcodePicker * @event */ static ready(): void; /** * Fired when a new frame is submitted to the external Scandit Data Capture library to be processed. As the frame is * not processed yet, the [[ScanResult.barcodes]] property will always be empty (no results yet). * * @asMemberOf BarcodePicker * @event * @param scanResult The result of the scanning operation on the image. */ static submitFrame(scanResult: ScanResult): void; /** * Fired when a new frame is processed by the external Scandit Data Capture library. This event is fired on every * frame, independently from the number of recognized barcodes or texts (can both be none). The returned barcodes and * texts are affected by [[ScanSettings]]'s *codeDuplicateFilter* and [[TextRecognitionSettings]]'s * *textDuplicateFilter* options. * * @asMemberOf BarcodePicker * @event * @param scanResult The result of the scanning operation on the image. */ static processFrame(scanResult: ScanResult): void; /** * Fired when new barcodes or texts are recognized in the image frame. The returned barcodes and texts are affected by * [[ScanSettings]]'s *codeDuplicateFilter* and [[TextRecognitionSettings]]'s *textDuplicateFilter* options. * * @asMemberOf BarcodePicker * @event * @param scanResult The result of the scanning operation on the image. */ static scan(scanResult: ScanResult): void; /** * Fired when an error occurs during scanning initialization and execution. The barcode picker will be automatically * paused when this happens. * * @asMemberOf BarcodePicker * @event * @param error The ScanditEngineError that was triggered. */ static scanError(error: Error): void; /** * Fired when an error occurs during camera access. * * @asMemberOf BarcodePicker * @event * @param error The Error that was triggered. */ static cameraAccessError(error: Error): void; /** * Create a [[BarcodePicker]] instance, creating the needed HTML in the given origin element. * If the *accessCamera* option is enabled (active by default) and the picker is not in Single Image Mode, * the available cameras are accessed and camera access permission is requested to the user if needed. * This object expects that at least a camera is available. The active camera is accessed and kept active during the * lifetime of the picker (also when hidden or scanning is paused), and is only released when [[destroy]] is called. * * It is required to having configured the library via [[configure]] before this object can be created. * * Depending on library configuration, parameters, device/browser features and user permissions for camera access, any * of the following errors could be the rejected result of the returned promise: * - `AbortError` * - `LibraryNotConfiguredError` * - `NoCameraAvailableError` * - `NoOriginElementError` * - `NotAllowedError` * - `NotFoundError` * - `NotReadableError` * - `SecurityError` * - `UnsupportedBrowserError` * * @param originElement The HTMLElement inside which all the necessary elements for the picker will be added. * @param visible <div class="tsd-signature-symbol">Default = true</div> * Whether the picker starts in a visible state. * @param singleImageModeSettings <div class="tsd-signature-symbol">Default = </div> * <pre><code>{ * desktop: { * usageStrategy: SingleImageModeSettings.UsageStrategy.FALLBACK, * informationElement: <HTMLElement>, * buttonElement: <SVGElement>, * containerStyle: { backgroundColor: "#333333" }, * informationStyle: { color: "#FFFFFF" }, * buttonStyle: { borderColor: "#FFFFFF", color: "#FFFFFF", fill: "#FFFFFF" } * }, * mobile: { * usageStrategy: SingleImageModeSettings.UsageStrategy.FALLBACK, * informationElement: <HTMLElement>, * buttonElement: <SVGElement>, * containerStyle: { backgroundColor: "#333333" }, * informationStyle: { color: "#FFFFFF" }, * buttonStyle: { borderColor: "#FFFFFF", color: "#FFFFFF", fill: "#FFFFFF" } * } * }</code></pre> * Settings for Single Image Mode: an alternative/fallback mode for a barcode picker to provide single camera * pictures to be scanned instead of continuous camera video stream access. In Single Image Mode users click/tap to * directly take a picture with the camera (mobile) or upload a file (desktop). Its usage depends on the given * settings and the camera video stream features provided by the OS/browser. * @param playSoundOnScan <div class="tsd-signature-symbol">Default = false</div> * Whether a sound is played on barcode/text recognition (iOS requires user input). * @param vibrateOnScan <div class="tsd-signature-symbol">Default = false</div> * Whether the device vibrates on barcode/text recognition (only Chrome & Firefox, requires user input). * @param scanningPaused <div class="tsd-signature-symbol">Default = false</div> * Whether the picker starts in a paused scanning state. * @param guiStyle <div class="tsd-signature-symbol">Default = GuiStyle.LASER</div> * The GUI style for the picker. * @param videoFit <div class="tsd-signature-symbol">Default = ObjectFit.CONTAIN</div> * The fit type for the video element of the picker. * @param cameraRecoveryText <div class="tsd-signature-symbol">Default = "Tap/click to resume scanning"</div> * The text to display to indicate to the user a necessary tap/click action on the picker to recover camera access. * @param laserArea <div class="tsd-signature-symbol">Default = undefined</div> * The area of the laser displayed when the GUI style is set to <em>laser</em> (the laser will match the width and be * vertically centered), by default the area will match the current [[ScanSettings]]'s <em>searchArea</em> option. * @param viewfinderArea <div class="tsd-signature-symbol">Default = undefined</div> * The area of the viewfinder displayed when the GUI style is set to <em>viewfinder</em>, by default the area will * match the current [[ScanSettings]]'s <em>searchArea</em> option. * @param enableCameraSwitcher <div class="tsd-signature-symbol">Default = true</div> * Whether to show a GUI button to switch between different cameras (when available). * @param enableTorchToggle <div class="tsd-signature-symbol">Default = true</div> * Whether to show a GUI button to toggle device torch on/off (when available, only Chrome). * @param enableTapToFocus <div class="tsd-signature-symbol">Default = true</div> * Whether to trigger a manual focus of the camera when clicking/tapping on the video (when available, only Chrome). * @param enablePinchToZoom <div class="tsd-signature-symbol">Default = true</div> * Whether to control the zoom of the camera when doing a pinching gesture on the video (when available, only Chrome). * @param accessCamera <div class="tsd-signature-symbol">Default = true</div> * Whether to immediately access the camera (and requesting user permissions if needed) on picker creation. * @param camera <div class="tsd-signature-symbol">Default = undefined</div> * The initial camera to be used for video input, if not specified the camera automatically selected depending on * the <em>cameraType</em> option will be used. * @param cameraType <div class="tsd-signature-symbol">Default = Camera.Type.BACK</div> * The preferred initial camera type (facing mode/direction) to be used for video input and Single Image Mode * (when available), by default the back or only camera will be used. If the <em>camera</em> option is provided then * <em>cameraType</em> is ignored. * @param cameraSettings <div class="tsd-signature-symbol">Default = undefined</div> * The camera options used when accessing the camera, by default <code>hd</code> resolution is used. * @param scanner <div class="tsd-signature-symbol">Default = undefined</div> * The scanner object responsible for scanning via the external Scandit Data Capture library * (a new scanner will be created and initialized if not provided). * @param scanSettings <div class="tsd-signature-symbol">Default = new ScanSettings()</div> * The configuration object for scanning options to be applied to the scanner (all symbologies disabled by default). * @param targetScanningFPS <div class="tsd-signature-symbol">Default = 30</div> * The target frames per second to be processed, the final speed is limited by the camera framerate (usually 30 FPS) * and the frame processing time of the device. By setting this to lower numbers devices can save power by performing * less work during scanning operations, depending on device speed (faster devices can "sleep" for longer periods). * Must be a number bigger than 0. * @returns A promise resolving to the created ready [[BarcodePicker]] object. */ static create(originElement: HTMLElement, { visible, singleImageModeSettings, playSoundOnScan, vibrateOnScan, scanningPaused, guiStyle, videoFit, cameraRecoveryText, laserArea, viewfinderArea, scanner, scanSettings, enableCameraSwitcher, enableTorchToggle, enableTapToFocus, enablePinchToZoom, accessCamera, camera, cameraType, cameraSettings, targetScanningFPS, /** * @hidden */ hideLogo, }?: { visible?: boolean; singleImageModeSettings?: SingleImageModeSettings; playSoundOnScan?: boolean; vibrateOnScan?: boolean; scanningPaused?: boolean; guiStyle?: BarcodePicker.GuiStyle; videoFit?: BarcodePicker.ObjectFit; cameraRecoveryText?: string; laserArea?: SearchArea; viewfinderArea?: SearchArea; scanner?: Scanner; scanSettings?: ScanSettings; enableCameraSwitcher?: boolean; enableTorchToggle?: boolean; enableTapToFocus?: boolean; enablePinchToZoom?: boolean; accessCamera?: boolean; camera?: Camera; cameraType?: Camera.Type; cameraSettings?: CameraSettings; targetScanningFPS?: number; /** * @hidden */ hideLogo?: boolean; }): Promise<BarcodePicker>; /** * Stop scanning and displaying video output, remove HTML elements added to the page, * destroy the internal [[Scanner]] (by default) and destroy the barcode picker itself; ensuring complete cleanup. * * This method should be called after you don't plan to use the picker anymore, * before the object is automatically cleaned up by JavaScript. * The barcode picker must not be used in any way after this call. * * If the [[Scanner]] is or will be in use for other purposes, the relative option can be passed to prevent * its destruction. * * @param destroyScanner Whether to destroy the internally used [[Scanner]] or not. */ destroy(destroyScanner?: boolean): void; /** * Apply a new set of scan settings to the internal scanner (replacing old settings). * * @param scanSettings The scan configuration object to be applied to the scanner. * @returns The updated [[BarcodePicker]] object. */ applyScanSettings(scanSettings: ScanSettings): BarcodePicker; /** * @returns Whether the scanning is currently paused. */ isScanningPaused(): boolean; /** * Pause the recognition of codes/texts in the input image. * * By default video from the camera is still shown, if the *pauseCamera* option is enabled the camera stream * is paused (camera access is fully interrupted) and will be resumed when calling [[resumeScanning]], * [[setActiveCamera]], [[setCameraType]] or [[accessCamera]], possibly requesting user permissions if needed. * * In Single Image Mode the input for submitting a picture is disabled. * * @param pauseCamera Whether to also pause the camera stream. * @returns The updated [[BarcodePicker]] object. */ pauseScanning(pauseCamera?: boolean): BarcodePicker; /** * Resume the recognition of codes/texts in the input image. * * If the camera stream was stopped when calling [[pauseScanning]], the camera stream is also resumed and * user permissions are requested if needed to resume video input. * * In Single Image Mode the input for submitting a picture is enabled. * * @returns The updated [[BarcodePicker]] object. */ resumeScanning(): Promise<BarcodePicker>; /** * @returns The currently active camera. */ getActiveCamera(): Camera | undefined; /** * Select a camera to be used for video input, if no camera is passed, the default one (based on *cameraType*) is * selected. * * If camera access is enabled, the camera is enabled and accessed. If not, the camera is stored and used for the * future initial camera access. * * Depending on device features and user permissions for camera access, any of the following errors * could be the rejected result of the returned promise: * - `AbortError` * - `NoCameraAvailableError` * - `NotAllowedError` * - `NotFoundError` * - `NotReadableError` * - `SecurityError` * * In Single Image Mode this method has no effect. * * @param camera The new camera to be used, by default the automatically detected back camera is used. * @param cameraSettings The camera options used when accessing the camera, by default `hd` resolution is used. * @returns A promise resolving to the updated [[BarcodePicker]] object when the camera is set * (and accessed, if camera access is currently enabled). */ setActiveCamera(camera?: Camera, cameraSettings?: CameraSettings): Promise<BarcodePicker>; /** * Select a camera to be used for video input by specifying the wanted camera type (facing mode/direction): the main * camera detected for the given camera type will be used. * * If camera access is enabled, the camera is enabled and accessed. If not, the camera type is stored and used for the * future initial camera access. * * If the target camera is already in use or no camera with the given type is found this method has no effect. * * Depending on device features and user permissions for camera access, any of the following errors * could be the rejected result of the returned promise: * - `AbortError` * - `NoCameraAvailableError` * - `NotAllowedError` * - `NotFoundError` * - `NotReadableError` * - `SecurityError` * * @param cameraType The new camera type (facing mode/direction) to be used for video input and Single Image Mode * (when available). * @returns A promise resolving to the updated [[BarcodePicker]] object when the camera is updated * (and accessed, if camera access is currently enabled). */ setCameraType(cameraType: Camera.Type): Promise<BarcodePicker>; /** * Try to apply new settings to the currently used camera for video input, * if no settings are passed the default ones are set. * * If camera access is enabled, the camera is updated and accessed with the new settings. If not, the camera settings * are stored and used for the future initial camera access. * * Depending on device features and user permissions for camera access, any of the following errors * could be the rejected result of the returned promise: * - `AbortError` * - `NoCameraAvailableError` * - `NotAllowedError` * - `NotFoundError` * - `NotReadableError` * - `SecurityError` * * In Single Image Mode this method has no effect. * * @param cameraSettings The new camera options used when accessing the camera, by default `hd` resolution is used. * @returns A promise resolving to the updated [[BarcodePicker]] object when the camera is updated * (and accessed, if camera access is currently enabled). */ applyCameraSettings(cameraSettings?: CameraSettings): Promise<BarcodePicker>; /** * @returns Whether the picker is in a visible state or not. */ isVisible(): boolean; /** * Enable or disable picker visibility. * * Note that this does not affect camera access, frame processing or any other picker logic. * * @param visible Whether the picker is in a visible state or not. * @returns The updated [[BarcodePicker]] object. */ setVisible(visible: boolean): BarcodePicker; /** * @returns Whether the currently selected camera's video is mirrored along the vertical axis. */ isMirrorImageEnabled(): boolean; /** * Enable or disable camera video mirroring along the vertical axis. * By default front cameras are automatically mirrored. * This setting is applied per camera and the method has no effect if no camera is currently selected. * * In Single Image Mode this method has no effect. * * @param enabled Whether the camera video is mirrored along the vertical axis. * @returns The updated [[BarcodePicker]] object. */ setMirrorImageEnabled(enabled: boolean): BarcodePicker; /** * @returns Whether a sound should be played on barcode/text recognition (iOS requires user input). * Note that the sound is played if there's at least a barcode or text not rejected via [[ScanResult.rejectCode]] or * [[ScanResult.rejectText]]. */ isPlaySoundOnScanEnabled(): boolean; /** * Enable or disable playing a sound on barcode/text recognition (iOS requires user input). * * The sound is played if there's at least a barcode or text not rejected via [[ScanResult.rejectCode]] or * [[ScanResult.rejectText]]. * * @param enabled Whether a sound should be played on barcode/text recognition. * @returns The updated [[BarcodePicker]] object. */ setPlaySoundOnScanEnabled(enabled: boolean): BarcodePicker; /** * @returns Whether the device should vibrate on barcode/text recognition (only Chrome & Firefox, requires user * input). * Note that the vibration is triggered if there's at least a barcode or text not rejected via * [[ScanResult.rejectCode]] or [[ScanResult.rejectText]]. */ isVibrateOnScanEnabled(): boolean; /** * Enable or disable vibrating the device on barcode/text recognition (only Chrome & Firefox, requires user input). * * The vibration is triggered if there's at least a barcode or text not rejected via [[ScanResult.rejectCode]] or * [[ScanResult.rejectText]]. * * @param enabled Whether the device should vibrate on barcode/text recognition. * @returns The updated [[BarcodePicker]] object. */ setVibrateOnScanEnabled(enabled: boolean): BarcodePicker; /** * @returns Whether a GUI button to switch between different cameras is shown (when available). */ isCameraSwitcherEnabled(): boolean; /** * Show or hide a GUI button to switch between different cameras (when available). * * In Single Image Mode this method has no effect. * * @param enabled Whether to show a GUI button to switch between different cameras. * @returns The updated [[BarcodePicker]] object. */ setCameraSwitcherEnabled(enabled: boolean): BarcodePicker; /** * @returns Whether a GUI button to toggle device torch on/off is shown (when available, only Chrome). */ isTorchToggleEnabled(): boolean; /** * Show or hide a GUI button to toggle device torch on/off (when available, only Chrome). * * In Single Image Mode this method has no effect. * * @param enabled Whether to show a GUI button to toggle device torch on/off. * @returns The updated [[BarcodePicker]] object. */ setTorchToggleEnabled(enabled: boolean): BarcodePicker; /** * @returns Whether manual camera focus when clicking/tapping on the video is enabled (when available, only Chrome). */ isTapToFocusEnabled(): boolean; /** * Enable or disable manual camera focus when clicking/tapping on the video (when available, only Chrome). * * In Single Image Mode this method has no effect. * * @param enabled Whether to enable manual camera focus when clicking/tapping on the video. * @returns The updated [[BarcodePicker]] object. */ setTapToFocusEnabled(enabled: boolean): BarcodePicker; /** * @returns Whether camera zoom control via pinching gesture on the video is enabled (when available, only Chrome). */ isPinchToZoomEnabled(): boolean; /** * Enable or disable camera zoom control via pinching gesture on the video (when available, only Chrome). * * In Single Image Mode this method has no effect. * * @param enabled Whether to enable camera zoom control via pinching gesture on the video. * @returns The updated [[BarcodePicker]] object. */ setPinchToZoomEnabled(enabled: boolean): BarcodePicker; /** * Enable or disable the torch/flashlight of the device (when available, only Chrome). * Changing active camera or camera settings will cause the torch to become disabled. * * A button on the [[BarcodePicker]] GUI to let the user toggle this functionality can also be set * on creation via the *enableTorchToggle* option (enabled by default, when available). * * In Single Image Mode this method has no effect. * * @param enabled Whether the torch should be enabled or disabled. * @returns A promise resolving to the updated [[BarcodePicker]] object when the torch is enabled/disabled. */ setTorchEnabled(enabled: boolean): Promise<BarcodePicker>; /** * Set the zoom level of the device (when available, only Chrome). * Changing active camera or camera settings will cause the zoom to be reset. * * In Single Image Mode this method has no effect. * * @param zoomPercentage The percentage of the max zoom (between 0 and 1). * @returns The updated [[BarcodePicker]] object. */ setZoom(zoomPercentage: number): Promise<BarcodePicker>; /** * @returns Whether the barcode picker has loaded the external Scandit Data Capture library and is ready to scan. */ isReady(): boolean; /** * Add the listener function to the listeners array for an event. * * No checks are made to see if the listener has already been added. * Multiple calls passing the same listener will result in the listener being added, and called, multiple times. * * @param eventName The name of the event to listen to. * @param listener The listener function. * @param once <div class="tsd-signature-symbol">Default = false</div> * Whether the listener should just be triggered only once and then discarded. * @returns The updated [[BarcodePicker]] object. */ on(eventName: EventName, listener: ListenerFn, once?: boolean): BarcodePicker; /** * Add the listener function to the listeners array for the [[ready]] event, fired when the external * Scandit Data Capture library has been loaded and the barcode picker can thus start to scan barcodes or texts. * If the library has already been loaded the listener is called immediately. * * No checks are made to see if the listener has already been added. * Multiple calls passing the same listener will result in the listener being added, and called, multiple times. * * @param eventName The name of the event to listen to. * @param listener The listener function. * @returns The updated [[BarcodePicker]] object. */ on(eventName: "ready", listener: () => void): BarcodePicker; /** * Add the listener function to the listeners array for the [[submitFrame]] event, fired when a new frame is submitted * to the external Scandit Data Capture library to be processed. As the frame is not processed yet, the * [[ScanResult.barcodes]] and [[ScanResult.texts]] properties will always be empty (no results yet). * * No checks are made to see if the listener has already been added. * Multiple calls passing the same listener will result in the listener being added, and called, multiple times. * * @param eventName The name of the event to listen to. * @param listener The listener function, which will be invoked with a [[ScanResult]] object. * @param once <div class="tsd-signature-symbol">Default = false</div> * Whether the listener should just be triggered only once and then discarded. * @returns The updated [[BarcodePicker]] object. */ on(eventName: "submitFrame", listener: (scanResult: ScanResult) => void, once?: boolean): BarcodePicker; /** * Add the listener function to the listeners array for the [[processFrame]] event, fired when a new frame is * processed. This event is fired on every frame, independently from the number of recognized barcodes or texts (can * both be none). The returned barcodes and texts are affected by [[ScanSettings]]'s *codeDuplicateFilter* and * [[TextRecognitionSettings]]'s *textDuplicateFilter* options. * * No checks are made to see if the listener has already been added. * Multiple calls passing the same listener will result in the listener being added, and called, multiple times. * * @param eventName The name of the event to listen to. * @param listener The listener function, which will be invoked with a [[ScanResult]] object. * @param once <div class="tsd-signature-symbol">Default = false</div> * Whether the listener should just be triggered only once and then discarded. * @returns The updated [[BarcodePicker]] object. */ on(eventName: "processFrame", listener: (scanResult: ScanResult) => void, once?: boolean): BarcodePicker; /** * Add the listener function to the listeners array for the [[scan]] event, fired when new barcodes or texts * are recognized in the image frame. The returned barcodes and texts are affected by [[ScanSettings]]'s * *codeDuplicateFilter* and [[TextRecognitionSettings]]'s *textDuplicateFilter* options. * * No checks are made to see if the listener has already been added. * Multiple calls passing the same listener will result in the listener being added, and called, multiple times. * * @param eventName The name of the event to listen to. * @param listener The listener function, which will be invoked with a [[ScanResult]] object. * @param once <div class="tsd-signature-symbol">Default = false</div> * Whether the listener should just be triggered only once and then discarded. * @returns The updated [[BarcodePicker]] object. */ on(eventName: "scan", listener: (scanResult: ScanResult) => void, once?: boolean): BarcodePicker; /** * Add the listener function to the listeners array for the [[scanError]] event, fired when an error occurs * during scanning initialization and execution. The barcode picker will be automatically paused when this happens. * * No checks are made to see if the listener has already been added. * Multiple calls passing the same listener will result in the listener being added, and called, multiple times. * * @param eventName The name of the event to listen to. * @param listener The listener function, which will be invoked with an `ScanditEngineError` object. * @param once <div class="tsd-signature-symbol">Default = false</div> * Whether the listener should just be triggered only once and then discarded. * @returns The updated [[BarcodePicker]] object. */ on(eventName: "scanError", listener: (error: Error) => void, once?: boolean): BarcodePicker; /** * Add the listener function to the listeners array for the [[cameraAccessError]] event, fired when an error occurs * during camera access.. * * No checks are made to see if the listener has already been added. * Multiple calls passing the same listener will result in the listener being added, and called, multiple times. * * @param eventName The name of the event to listen to. * @param listener The listener function, which will be invoked with an `Error` object. * @param once <div class="tsd-signature-symbol">Default = false</div> * Whether the listener should just be triggered only once and then discarded. * @returns The updated [[BarcodePicker]] object. */ on(eventName: "cameraAccessError", listener: (error: Error) => void, once?: boolean): BarcodePicker; /** * Remove the specified listener from the given event's listener array. * * @param eventName The name of the event from which to remove the listener. * @param listener The listener function to be removed. * @returns The updated [[BarcodePicker]] object. */ removeListener(eventName: EventName, listener: ListenerFn): BarcodePicker; /** * Remove all listeners from the given event's listener array. * * @param eventName The name of the event from which to remove all listeners. * @returns The updated [[BarcodePicker]] object. */ removeAllListeners(eventName: EventName): BarcodePicker; /** * *See the [[on]] method.* * * @param eventName The name of the event to listen to. * @param listener The listener function. * @param once <div class="tsd-signature-symbol">Default = false</div> * Whether the listener should just be triggered only once and then discarded. * @returns The updated [[BarcodePicker]] object. */ addListener(eventName: EventName, listener: ListenerFn, once?: boolean): BarcodePicker; /** * Set the GUI style for the picker. * * In Single Image Mode this method has no effect. * * When the GUI style is set to *laser* or *viewfinder*, the GUI will flash on barcode/text recognition. * Note that the GUI will flash if there's at least a barcode or text not rejected via [[ScanResult.rejectCode]] or * [[ScanResult.rejectText]]. * * @param guiStyle The new GUI style to be applied. * @returns The updated [[BarcodePicker]] object. */ setGuiStyle(guiStyle: BarcodePicker.GuiStyle): BarcodePicker; /** * Set the fit type for the video element of the picker. * * If the "cover" type is selected the maximum available search area for barcode/text detection is (continuously) * adjusted automatically according to the visible area of the picker. * * In Single Image Mode this method has no effect. * * @param objectFit The new fit type to be applied. * @returns The updated [[BarcodePicker]] object. */ setVideoFit(objectFit: BarcodePicker.ObjectFit): BarcodePicker; /** * Access the currently set or default camera, requesting user permissions if needed. * This method is meant to be used after the picker has been initialized with disabled camera access * (*accessCamera*=false) or after [[pauseScanning]] has been called with the pause camera stream option. * Calling this doesn't do anything if the camera is already being accessed. * * Depending on device features and user permissions for camera access, any of the following errors * could be the rejected result of the returned promise: * - `AbortError` * - `NoCameraAvailableError` * - `NotAllowedError` * - `NotFoundError` * - `NotReadableError` * - `SecurityError` * * In Single Image Mode this method has no effect. * * @returns A promise resolving to the updated [[BarcodePicker]] object when the camera is accessed. */ accessCamera(): Promise<BarcodePicker>; /** * Create a new parser object. * * @param dataFormat The format of the input data for the parser. * @returns The newly created parser. */ createParserForFormat(dataFormat: Parser.DataFormat): Parser; /** * Reassign the barcode picker to a different HTML element. * * All the barcode picker elements inside the current origin element will be moved to the new given one. * * If an invalid element is given, a `NoOriginElementError` error is thrown. * * @param originElement The HTMLElement into which all the necessary elements for the picker will be moved. * @returns The updated [[BarcodePicker]] object. */ reassignOriginElement(originElement: HTMLElement): BarcodePicker; /** * Set the target frames per second to be processed by the external Scandit Data Capture library. * * The final speed is limited by the camera framerate (usually 30 FPS) and the frame processing time of the device. * By setting this to lower numbers devices can save power by performing less work during scanning operations, * depending on device speed (faster devices can "sleep" for longer periods). * * In Single Image Mode this method has no effect. * * @param targetScanningFPS The target frames per second to be processed. * Must be a number bigger than 0, by default set to 30. * @returns The updated [[BarcodePicker]] object. */ setTargetScanningFPS(targetScanningFPS: number): BarcodePicker; /** * @returns The internally used initialized (and possibly configured) [[Scanner]] object instance. */ getScanner(): Scanner; /** * Clear the internal scanner session. * * This removes all recognized barcodes/texts from the scanner session and allows them to be scanned again in case a * custom *codeDuplicateFilter* and/or *textDuplicateFilter* option was set in [[ScanSettings]] or * [[TextRecognitionSettings]]. * * @returns The updated [[BarcodePicker]] object. */ clearSession(): BarcodePicker; /** * Set the area of the laser displayed when the GUI style is set to *laser* (the laser will match the width and be * vertically centered). * Note that this functionality affects UI only and doesn't change the actual *searchArea* option set via * [[ScanSettings]]. If no area is passed, the default automatic size behaviour is set, where the laser will match * the current area of the image in which barcodes/texts are searched, controlled via the *searchArea* option in * [[ScanSettings]]. * * @param area The new search area, by default the area will match [[ScanSettings]]'s *searchArea* option. * @returns The updated [[BarcodePicker]] object. */ setLaserArea(area?: SearchArea): BarcodePicker; /** * Set the area of the viewfinder displayed when the GUI style is set to *viewfinder*. * Note that this functionality affects UI only and doesn't change the actual search area set via [[ScanSettings]]. * If no area is passed, the default automatic size behaviour is set, where the viewfinder will match the current area * of the image in which barcodes/texts are searched, controlled via the *searchArea* option in [[ScanSettings]]. * * @param area The new search area, by default the area will match the [[ScanSettings]]'s *searchArea*. * @returns The updated [[BarcodePicker]] object. */ setViewfinderArea(area?: SearchArea): BarcodePicker; /** * @hidden * * Pause the camera stream (camera access is fully interrupted). * * @returns The updated [[BarcodePicker]] object. */ pauseCameraAccess(): BarcodePicker; private triggerCameraAccessError; private handleScanResult; private scheduleVideoProcessing; private scheduleNextVideoProcessing; private processVideoFrame; private videoProcessing; private handleScannerReady; } export declare namespace BarcodePicker { /** * GUI style to be used by a barcode picker, used to hint barcode/text placement in the frame. */ enum GuiStyle { /** * No GUI is shown to indicate where the barcode/text should be placed. * Be aware that the Scandit logo continues to be displayed as showing it is part of the license agreement. */ NONE = "none", /** * A laser line is shown. */ LASER = "laser", /** * A rectangular viewfinder with rounded corners is shown. */ VIEWFINDER = "viewfinder" } /** * Fit type used to control the resizing (scale) of the barcode picker to fit in its container *originElement*. */ enum ObjectFit { /** * Scale to maintain aspect ratio while fitting within the *originElement*'s content box. * Aspect ratio is preserved, so the barcode picker will be "letterboxed" if its aspect ratio * does not match the aspect ratio of the box. */ CONTAIN = "contain", /** * Scale to maintain aspect ratio while filling the *originElement*'s entire content box. * Aspect ratio is preserved, so the barcode picker will be clipped to fit if its aspect ratio * does not match the aspect ratio of the box. */ COVER = "cover" } } export {};