eewing
284 lines
13 KiB
TypeScript
284 lines
13 KiB
TypeScript
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;
|
|
}
|