@zxing/browser

import { BarcodeFormat, BinaryBitmap, DecodeHintType, Reader, Result } from '@zxing/library'; import { DecodeContinuouslyCallback } from '../common/DecodeContinuouslyCallback'; import { HTMLVisualMediaElement } from '../common/HTMLVisualMediaElement'; import { IScannerControls } from '../common/IScannerControls'; import { IBrowserCodeReaderOptions } from './IBrowserCodeReaderOptions'; /** * Base class for browser code reader. */ export declare class BrowserCodeReader { protected readonly reader: Reader; hints: Map<DecodeHintType, any>; /** * Allows to change the possible formats the decoder should * search for while scanning some image. Useful for changing * the possible formats during BrowserCodeReader::scan. */ set possibleFormats(formats: BarcodeFormat[]); /** * Defines what the videoElement src will be. * * @param videoElement * @param stream The stream to be added as a source. */ static addVideoSource(videoElement: HTMLVideoElement, stream: MediaStream): void; /** * Enables or disables the torch in a media stream. * * @experimental This doesn't work across all browsers and is still a Draft. */ static mediaStreamSetTorch(track: MediaStreamTrack, onOff: boolean): Promise<void>; /** * Checks if the stream has torch support. */ static mediaStreamIsTorchCompatible(params: MediaStream): boolean; /** * * @param track The media stream track that will be checked for compatibility. */ static mediaStreamIsTorchCompatibleTrack(track: MediaStreamTrack): boolean; /** * Checks if the given video element is currently playing. */ static isVideoPlaying(video: HTMLVideoElement): boolean; /** * Searches and validates a media element. */ static getMediaElement(mediaElementId: string, type: string): HTMLVisualMediaElement; /** * Receives a source and makes sure to return a Video Element from it or fail. */ static createVideoElement(videoThingy?: HTMLVideoElement | string): HTMLVideoElement; /** * Receives a source and makes sure to return an Image Element from it or fail. */ static prepareImageElement(imageSource?: HTMLImageElement | string): HTMLImageElement; /** * Sets a HTMLVideoElement for scanning or creates a new one. * * @param videoElem The HTMLVideoElement to be set. */ static prepareVideoElement(videoElem?: HTMLVideoElement | string): HTMLVideoElement; /** * Checks if and HTML image is loaded. */ static isImageLoaded(img: HTMLImageElement): boolean; /** * Creates a binaryBitmap based in a canvas. * * @param canvas HTML canvas element containing the image source draw. */ static createBinaryBitmapFromCanvas(canvas: HTMLCanvasElement): BinaryBitmap; /** * Overwriting this allows you to manipulate the snapshot image in anyway you want before decode. */ static drawImageOnCanvas(canvasElementContext: CanvasRenderingContext2D, srcElement: HTMLVisualMediaElement): void; static getMediaElementDimensions(mediaElement: HTMLVisualMediaElement): { height: number; width: number; }; /** * 🖌 Prepares the canvas for capture and scan frames. */ static createCaptureCanvas(mediaElement: HTMLVisualMediaElement): HTMLCanvasElement; /** * Just tries to play the video and logs any errors. * The play call is only made is the video is not already playing. */ static tryPlayVideo(videoElement: HTMLVideoElement): Promise<boolean>; /** * Creates a canvas and draws the current image frame from the media element on it. * * @param mediaElement HTML media element to extract an image frame from. */ static createCanvasFromMediaElement(mediaElement: HTMLVisualMediaElement): HTMLCanvasElement; /** * Creates a binaryBitmap based in some image source. * * @param mediaElement HTML element containing drawable image source. */ static createBinaryBitmapFromMediaElem(mediaElement: HTMLVisualMediaElement): BinaryBitmap; static destroyImageElement(imageElement: HTMLImageElement): void; /** * Lists all the available video input devices. */ static listVideoInputDevices(): Promise<MediaDeviceInfo[]>; /** * Let's you find a device using it's Id. */ static findDeviceById(deviceId: string): Promise<MediaDeviceInfo | undefined>; /** * Unbinds a HTML video src property. */ static cleanVideoSource(videoElement: HTMLVideoElement): void; /** * Stops all media streams that are created. */ static releaseAllStreams(): void; /** * Waits for a video to load and then hits play on it. * To accomplish that, it binds listeners and callbacks to the video element. * * @param element The video element. * @param callbackFn Callback invoked when the video is played. */ protected static playVideoOnLoadAsync(element: HTMLVideoElement, timeout: number): Promise<boolean>; /** * Sets the new stream and request a new decoding-with-delay. * * @param stream The stream to be shown in the video element. * @param decodeFn A callback for the decode method. */ protected static attachStreamToVideo(stream: MediaStream, preview?: string | HTMLVideoElement, previewPlayTimeout?: number): Promise<HTMLVideoElement>; /** * Keeps track to created media streams. * @private there is no need this array to be accessible from outside. */ private static streamTracker; /** * Returns a Promise that resolves when the given image element loads. */ private static _waitImageLoad; /** * Checks if the `callbackFn` is defined, otherwise throws. */ private static checkCallbackFnOrThrow; /** * Standard method to dispose a media stream object. */ private static disposeMediaStream; /** * BrowserCodeReader specific configuration options. */ protected readonly options: IBrowserCodeReaderOptions; /** * Creates an instance of BrowserCodeReader. * @param {Reader} reader The reader instance to decode the barcode * @param hints Holds the hints the user sets for the Reader. */ constructor(reader: Reader, hints?: Map<DecodeHintType, any>, options?: IBrowserCodeReaderOptions); /** * Gets the BinaryBitmap for ya! (and decodes it) */ decode(element: HTMLVisualMediaElement): Result; /** * Call the encapsulated readers decode */ decodeBitmap(binaryBitmap: BinaryBitmap): Result; /** * Decodes some barcode from a canvas! */ decodeFromCanvas(canvas: HTMLCanvasElement): Result; /** * Decodes something from an image HTML element. */ decodeFromImageElement(source: string | HTMLImageElement): Promise<Result>; /** * Decodes an image from a URL. */ decodeFromImageUrl(url?: string): Promise<Result>; /** * Continuously tries to decode the barcode from a stream obtained from the given constraints * while showing the video in the specified video element. * * @param {MediaStream} [constraints] the media stream constraints to get s valid media stream to decode from * @param {string|HTMLVideoElement} [previewElem] the video element in page where to show the video while * decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in * which case no video will be shown. */ decodeFromConstraints(constraints: MediaStreamConstraints, previewElem: string | HTMLVideoElement | undefined, callbackFn: DecodeContinuouslyCallback): Promise<IScannerControls>; /** * In one attempt, tries to decode the barcode from a stream obtained from the given constraints * while showing the video in the specified video element. * * @param {MediaStream} [constraints] the media stream constraints to get s valid media stream to decode from * @param {string|HTMLVideoElement} [preview] the video element in page where to show the video * while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, * in which case no video will be shown. */ decodeFromStream(stream: MediaStream, preview: string | HTMLVideoElement | undefined, callbackFn: DecodeContinuouslyCallback): Promise<IScannerControls>; /** * Continuously tries to decode the barcode from the device specified by device while showing * the video in the specified video element. * * @param {string|null} [deviceId] the id of one of the devices obtained after calling * getVideoInputDevices. Can be undefined, in this case it will decode from one of the * available devices, preferring the main camera (environment facing) if available. * @param {string|HTMLVideoElement|null} [video] the video element in page where to show the video * while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, * in which case no video will be shown. */ decodeFromVideoDevice(deviceId: string | undefined, previewElem: string | HTMLVideoElement | undefined, callbackFn: DecodeContinuouslyCallback): Promise<IScannerControls>; /** * Decodes something from an image HTML element. */ decodeFromVideoElement(source: string | HTMLVideoElement, callbackFn: DecodeContinuouslyCallback): Promise<IScannerControls>; /** * Decodes a video from a URL until it ends. */ decodeFromVideoUrl(url: string, callbackFn: DecodeContinuouslyCallback): Promise<IScannerControls>; /** * In one attempt, tries to decode the barcode from a stream obtained from the given * constraints while showing the video in the specified video element. * * @param constraints the media stream constraints to get s valid media stream to decode from * @param videoSource the video element in page where to show the video while decoding. * Can be either an element id or directly an HTMLVideoElement. Can be undefined, * in which case no video will be shown. * The decoding result. */ decodeOnceFromConstraints(constraints: MediaStreamConstraints, videoSource?: string | HTMLVideoElement): Promise<Result>; /** * In one attempt, tries to decode the barcode from a stream obtained from the given * constraints while showing the video in the specified video element. * * @param {MediaStream} [constraints] the media stream constraints to get s valid media stream to decode from * @param {string|HTMLVideoElement} [video] the video element in page where to show the video while decoding. * Can be either an element id or directly an HTMLVideoElement. Can be undefined, * in which case no video will be shown. */ decodeOnceFromStream(stream: MediaStream, preview?: string | HTMLVideoElement): Promise<Result>; /** * In one attempt, tries to decode the barcode from the device specified by deviceId * while showing the video in the specified video element. * * @param deviceId the id of one of the devices obtained after calling getVideoInputDevices. * Can be undefined, in this case it will decode from one of the available devices, * preferring the main camera (environment facing) if available. * @param videoSource the video element in page where to show the video while decoding. * Can be either an element id or directly an HTMLVideoElement. Can be undefined, * in which case no video will be shown. */ decodeOnceFromVideoDevice(deviceId?: string, videoSource?: string | HTMLVideoElement): Promise<Result>; /** * Decodes something from an image HTML element. */ decodeOnceFromVideoElement(source: string | HTMLVideoElement): Promise<Result>; /** * Decodes a video from a URL. */ decodeOnceFromVideoUrl(url: string): Promise<Result>; /** * Tries to decode from the video input until it finds some value. */ scanOneResult(element: HTMLVisualMediaElement, retryIfNotFound?: boolean, retryIfChecksumError?: boolean, retryIfFormatError?: boolean): Promise<Result>; /** * Continuously decodes from video input. * * @param element HTML element to scan/decode from. It will not be disposed or destroyed. * @param callbackFn Called after every scan attempt, being it successful or errored. * @param finalizeCallback Called after scan process reaches the end or stop is called. */ scan(element: HTMLVisualMediaElement, callbackFn: DecodeContinuouslyCallback, finalizeCallback?: (error?: Error) => void): IScannerControls; /** * Waits for the image to load and then tries to decode it. */ private _decodeOnLoadImage; /** * Get MediaStream from browser to be used. * @param constraints constraints the media stream constraints to get s valid media stream to decode from. * @private For private use. */ private getUserMedia; }