videomail-client 16.0.3 → 16.1.0

package/dist/umd/index.js

@@ -11121,7 +11121,7 @@
             var client = __webpack_require__("Q");
             var client_default = /*#__PURE__*/ __webpack_require__.n(client);
             var package_namespaceObject = {
-                rE: "16.0.3"
+                rE: "16.1.0"
             };
             function isAudioEnabled(options) {
                 return Boolean(options.audio.enabled);
@@ -18636,10 +18636,14 @@
                     this.on("USER_MEDIA_READY", ()=>{
                         this.facingMode?.show();
                     });
+                    this.on("CAMERA_RECOVERING", ()=>{
+                        this.facingMode?.hide();
+                    });
                     this.on("RECORDING", ()=>{
                         this.startRecording();
                     });
                     this.on("RESUMING", ()=>{
+                        this.hidePause();
                         this.resumeRecording();
                     });
                     this.on("STOPPING", ()=>{
@@ -19254,6 +19258,7 @@
             class AudioRecorder {
                 scriptProcessor;
                 audioInput;
+                volume;
                 vcAudioContext;
                 userMedia;
                 options;
@@ -19276,9 +19281,19 @@
                     const float32Array = e.inputBuffer.getChannelData(0);
                     cb(new esm(float32Array));
                 }
+                disconnect() {
+                    if (this.scriptProcessor) {
+                        this.scriptProcessor.onaudioprocess = null;
+                        this.scriptProcessor.disconnect();
+                    }
+                    this.audioInput?.disconnect();
+                    this.volume?.disconnect();
+                }
                 init(localMediaStream) {
                     this.options.logger.debug("AudioRecorder: init()");
+                    this.disconnect();
                     const volume = this.getAudioContext().createGain();
+                    this.volume = volume;
                     try {
                         this.audioInput = this.getAudioContext().createMediaStreamSource(localMediaStream);
                     } catch (exc) {
@@ -19310,10 +19325,13 @@
                         this.onAudioProcess(e, cb);
                     };
                 }
+                async resume() {
+                    const context = this.getAudioContext();
+                    if ("running" !== context.state) await context.resume();
+                }
                 stop() {
                     this.options.logger.debug("AudioRecorder: stop()");
-                    if (this.scriptProcessor) this.scriptProcessor.onaudioprocess = null;
-                    if (this.audioInput) this.audioInput.disconnect();
+                    this.disconnect();
                     if (this.hasAudioContext()) this.getAudioContext().close().then(()=>{
                         this.options.logger.debug("AudioRecorder: audio context is closed");
                         this.vcAudioContext = void 0;
@@ -19358,6 +19376,8 @@
                 onLoadedMetaDataReached = false;
                 playingPromiseReached = false;
                 videoTrackLabel;
+                clearInitializationListeners;
+                initializationId = 0;
                 outputEvent = (e)=>{
                     this.logEvent(e.type, {
                         readyState: this.rawVisualUserMedia?.readyState
@@ -19399,6 +19419,16 @@
                         this.currentVisualStream = void 0;
                     }
                 }
+                async restorePlayback() {
+                    if (!this.rawVisualUserMedia) throw new Error("No camera preview is available.");
+                    await this.rawVisualUserMedia.play();
+                    await this.audioRecorder?.resume();
+                }
+                hasLiveStream() {
+                    const videoReady = this.currentVisualStream?.getVideoTracks().some((track)=>"live" === track.readyState && track.enabled && !track.muted);
+                    const audioReady = !isAudioEnabled(this.options) || this.currentVisualStream?.getAudioTracks().some((track)=>"live" === track.readyState && track.enabled && !track.muted);
+                    return Boolean(this.currentVisualStream?.active && videoReady && audioReady);
+                }
                 hasEnded() {
                     if (this.rawVisualUserMedia?.ended) return this.rawVisualUserMedia.ended;
                     return !this.currentVisualStream?.active;
@@ -19413,6 +19443,7 @@
                 }
                 unloadRemainingEventListeners() {
                     this.options.logger.debug("UserMedia: unloadRemainingEventListeners()");
+                    this.clearInitializationListeners?.();
                     mediaEvents.forEach((eventName)=>{
                         this.rawVisualUserMedia?.removeEventListener(eventName, this.outputEvent);
                     });
@@ -19422,11 +19453,13 @@
                     this.removeListener("SENDING_FIRST_FRAME");
                     this.audioRecorder?.record(audioCallback);
                 }
-                init(localMediaStream, videoCallback, audioCallback, endedEarlyCallback, switchingFacingMode) {
+                init(localMediaStream, videoCallback, audioCallback, endedEarlyCallback, params) {
+                    this.clearInitializationListeners?.();
                     this.stop(localMediaStream, {
                         aboutToInitialize: true,
-                        switchingFacingMode
+                        preserveRecordingState: Boolean(params?.switchingFacingMode || params?.recovering)
                     });
+                    const initializationId = ++this.initializationId;
                     this.onPlayReached = false;
                     this.onLoadedMetaDataReached = false;
                     this.playingPromiseReached = false;
@@ -19439,18 +19472,25 @@
                         this.rawVisualUserMedia?.removeEventListener("play", onPlay);
                         this.rawVisualUserMedia?.removeEventListener("loadedmetadata", onLoadedMetaData);
                     };
+                    this.clearInitializationListeners = ()=>{
+                        this.rawVisualUserMedia?.removeEventListener("play", onPlay);
+                        this.rawVisualUserMedia?.removeEventListener("loadedmetadata", onLoadedMetaData);
+                        this.clearInitializationListeners = void 0;
+                    };
                     const play = ()=>{
                         try {
                             this.rawVisualUserMedia?.load();
                             if (this.rawVisualUserMedia?.paused) {
                                 this.options.logger.debug(`UserMedia: play(): media.readyState=${this.rawVisualUserMedia.readyState}, media.paused=${this.rawVisualUserMedia.paused}, media.ended=${this.rawVisualUserMedia.ended}, media.played=${string_pretty(this.rawVisualUserMedia.played)}`);
                                 this.rawVisualUserMedia.play().then(()=>{
+                                    if (initializationId !== this.initializationId) return;
                                     if (!this.playingPromiseReached) {
                                         this.options.logger.debug("UserMedia: play promise successful. Playing now.");
                                         this.playingPromiseReached = true;
                                     }
                                 }).catch((exc)=>{
-                                    if (exc instanceof Error) this.options.logger.warn(`Caught pending user media promise exception: ${exc.toString()}`);
+                                    if (initializationId !== this.initializationId) return;
+                                    if (exc instanceof Error && !params?.recovering) this.options.logger.warn(`Caught pending user media promise exception: ${exc.toString()}`);
                                     else {
                                         unloadAllEventListeners();
                                         endedEarlyCallback(error_createError({
@@ -19471,16 +19511,28 @@
                         this.options.logger.debug(`UserMedia: fireCallbacks(readyState=${readyState}, onPlayReached=${this.onPlayReached}, onLoadedMetaDataReached=${this.onLoadedMetaDataReached})`);
                         if (this.onPlayReached && this.onLoadedMetaDataReached) if (this.audioRecorder) try {
                             this.audioRecorder.init(localMediaStream);
-                            this.on("SENDING_FIRST_FRAME", ()=>{
-                                this.audioRecord(audioCallback);
-                            });
-                            videoCallback();
+                            const onAudioReady = ()=>{
+                                if (initializationId !== this.initializationId || this.currentVisualStream !== localMediaStream) return;
+                                if (this.recording) this.audioRecord(audioCallback);
+                                else this.on("SENDING_FIRST_FRAME", ()=>{
+                                    this.audioRecord(audioCallback);
+                                });
+                                this.clearInitializationListeners?.();
+                                videoCallback();
+                            };
+                            if (params?.recovering) this.audioRecorder.resume().then(onAudioReady).catch(endedEarlyCallback);
+                            else onAudioReady();
                         } catch (exc) {
                             unloadAllEventListeners();
-                            this.stop();
+                            this.stop(void 0, {
+                                preserveRecordingState: Boolean(params?.recovering)
+                            });
                             endedEarlyCallback(exc);
                         }
-                        else videoCallback();
+                        else {
+                            this.clearInitializationListeners?.();
+                            videoCallback();
+                        }
                     };
                     const onPlay = ()=>{
                         try {
@@ -19550,9 +19602,8 @@
                         this.setVisualStream(localMediaStream);
                         play();
                     } catch (exc) {
-                        this.emit("ERROR", {
-                            exc
-                        });
+                        unloadAllEventListeners();
+                        endedEarlyCallback(exc);
                     }
                 }
                 getVideoTrackLabel() {
@@ -19565,6 +19616,8 @@
                     try {
                         let chosenStream = visualStream;
                         if (!params?.aboutToInitialize) {
+                            this.initializationId++;
+                            this.clearInitializationListeners?.();
                             chosenStream ??= this.currentVisualStream;
                             const tracks = chosenStream?.getTracks();
                             if (tracks) tracks.forEach((track)=>{
@@ -19574,7 +19627,7 @@
                             this.audioRecorder?.stop();
                             this.audioRecorder = void 0;
                         }
-                        if (!params?.switchingFacingMode) this.paused = this.recording = false;
+                        if (!params?.preserveRecordingState) this.paused = this.recording = false;
                     } catch (exc) {
                         this.emit("ERROR", {
                             exc
@@ -19672,6 +19725,7 @@
                 originalAnimationFrameObject;
                 samplesCount = 0;
                 framesCount = 0;
+                recordingAudioSampleRate;
                 recordingStats;
                 confirmedFrameNumber = 0;
                 confirmedSampleNumber = 0;
@@ -19690,6 +19744,10 @@
                 ctx;
                 userMediaLoaded;
                 userMediaLoading = false;
+                mediaRequestId = 0;
+                cameraRecovery;
+                resolveCameraRecovery;
+                resumeAfterCameraRecovery = false;
                 submitting = false;
                 unloaded;
                 stopTime;
@@ -19953,7 +20011,9 @@
                     this.pingInterval = void 0;
                 }
                 onAudioSample(audioSample) {
-                    if (this.recordingTransportFailed) return;
+                    if (this.recordingTransportFailed || this.cameraRecovery) return;
+                    const sampleRate = this.userMedia?.getAudioSampleRate();
+                    if (sampleRate && sampleRate > 0) this.recordingAudioSampleRate ??= sampleRate;
                     this.samplesCount++;
                     this.mediaTransmissionStarted = true;
                     const audioBuffer = audioSample.toBuffer();
@@ -19966,19 +20026,26 @@
                     try {
                         this.options.logger.debug(`Recorder: onUserMediaReady(${params ? string_pretty(params) : ""})`);
                         const switchingFacingMode = params?.switchingFacingMode;
+                        if (params?.recovering) {
+                            if (!this.userMedia?.hasLiveStream()) return void this.failCameraRecovery(new Error("The restored camera has no live tracks."));
+                            if (void 0 !== this.recordingAudioSampleRate && this.userMedia.getAudioSampleRate() !== this.recordingAudioSampleRate) return void this.failCameraRecovery(new Error("The audio sample rate changed during recovery."));
+                        }
                         this.userMediaLoading = this.blocking = this.unloaded = this.submitting = false;
                         this.userMediaLoaded = true;
                         this.clearUserMediaTimeout();
-                        if (!switchingFacingMode) this.loop = this.createLoop();
+                        if (!switchingFacingMode && !params?.recovering) this.loop = this.createLoop();
                         this.show();
                         if (params?.recordWhenReady) this.record();
                         this.emit("USER_MEDIA_READY", {
                             switchingFacingMode: params?.switchingFacingMode,
+                            recovering: params?.recovering,
                             paused: this.isPaused(),
                             recordWhenReady: params?.recordWhenReady
                         });
+                        if (params?.recovering) this.finishCameraRecovery(true);
                     } catch (exc) {
-                        this.emit("ERROR", {
+                        if (params?.recovering) this.failCameraRecovery(exc);
+                        else this.emit("ERROR", {
                             exc
                         });
                     }
@@ -20349,6 +20416,7 @@
                     return this.blocking;
                 }
                 userMediaErrorCallback(err, usedConstraints) {
+                    if (this.cameraRecovery) return void this.failCameraRecovery(err);
                     if (this.unloaded) return void this.options.logger.debug(`Recorder: already unloaded. Not going to throw error ${string_pretty(err)}`);
                     this.userMediaLoading = false;
                     this.clearUserMediaTimeout();
@@ -20380,7 +20448,7 @@
                         });
                     }
                 }
-                getUserMediaCallback(localStream, params) {
+                getUserMediaCallback(localStream, params, requestId = this.mediaRequestId) {
                     if (!this.userMedia) {
                         localStream.getTracks().forEach((track)=>{
                             track.stop();
@@ -20393,20 +20461,20 @@
                     this.options.logger.debug(`Recorder: getUserMediaCallback(${params ? string_pretty(params) : ""})`);
                     if (this.showUserMedia()) try {
                         this.userMedia.init(localStream, ()=>{
-                            if (!this.unloaded) this.onUserMediaReady(params);
+                            if (!this.unloaded && requestId === this.mediaRequestId) this.onUserMediaReady(params);
                         }, this.onAudioSample.bind(this), (err)=>{
-                            if (!this.unloaded) this.userMediaErrorCallback(err, {
+                            if (!this.unloaded && requestId === this.mediaRequestId) this.userMediaErrorCallback(err, {
                                 audio: isAudioEnabled(this.options)
                             });
-                        }, params?.switchingFacingMode);
+                        }, params);
                     } catch (exc) {
                         localStream.getTracks().forEach((track)=>{
                             track.stop();
                         });
                         this.userMediaLoading = false;
                         this.clearUserMediaTimeout();
-                        this.emit("ERROR", {
-                            exc
+                        this.userMediaErrorCallback(exc, {
+                            audio: isAudioEnabled(this.options)
                         });
                     }
                     else {
@@ -20415,12 +20483,14 @@
                         });
                         this.userMediaLoading = false;
                         this.clearUserMediaTimeout();
+                        this.cancelCameraRecovery();
                     }
                 }
                 loadGenuineUserMedia(params) {
                     this.options.logger.debug(`Recorder: loadGenuineUserMedia(${params ? string_pretty(params) : ""})`);
                     this.emit("ASKING_WEBCAM_PERMISSION");
                     this.userMediaLoading = true;
+                    const requestId = ++this.mediaRequestId;
                     const constraints = {
                         video: {
                             frameRate: {
@@ -20434,18 +20504,18 @@
                     this.options.logger.debug(string_summarize("Recorder: available webcam constraints are:", navigator.mediaDevices.getSupportedConstraints()));
                     const streamPromise = navigator.mediaDevices.getUserMedia(constraints);
                     streamPromise.then((localStream)=>{
-                        if (this.unloaded) return void localStream.getTracks().forEach((track)=>{
+                        if (this.unloaded || requestId !== this.mediaRequestId) return void localStream.getTracks().forEach((track)=>{
                             track.stop();
                         });
-                        this.getUserMediaCallback(localStream, params);
+                        this.getUserMediaCallback(localStream, params, requestId);
                     }).catch((reason)=>{
-                        if (!this.unloaded) this.userMediaErrorCallback(reason, constraints);
+                        if (!this.unloaded && requestId === this.mediaRequestId) this.userMediaErrorCallback(reason, constraints);
                     });
                 }
                 configureVideoConstraints(constraints, params) {
                     const videoConstraints = "object" == typeof constraints.video ? constraints.video : void 0;
                     if (!videoConstraints) return;
-                    if (params?.switchingFacingMode) videoConstraints.facingMode = params.switchingFacingMode;
+                    if (params?.switchingFacingMode || params?.recovering) videoConstraints.facingMode = params.switchingFacingMode || this.facingMode;
                     if (this.options.video.width) videoConstraints.width = {
                         ideal: this.options.video.width
                     };
@@ -20473,8 +20543,8 @@
                             if (!this.userMediaLoaded) {
                                 this.userMediaLoading = false;
                                 const err = util_getBrowser(this.options).getNoAccessIssue();
-                                this.emit("ERROR", {
-                                    err
+                                this.userMediaErrorCallback(err, {
+                                    audio: isAudioEnabled(this.options)
                                 });
                             }
                         }, this.options.timeouts.userMedia);
@@ -20484,6 +20554,7 @@
                         this.clearUserMediaTimeout();
                         this.options.logger.debug("Recorder: failed to load genuine user media");
                         this.userMediaLoading = false;
+                        if (this.cameraRecovery) return void this.failCameraRecovery(exc);
                         const errorListeners = this.getListeners("ERROR");
                         if (errorListeners?.length) this.emit("ERROR", {
                             exc
@@ -20607,9 +20678,10 @@
                     return this.recordingStats;
                 }
                 getAudioSampleRate() {
-                    return this.userMedia?.getAudioSampleRate();
+                    return this.recordingAudioSampleRate ?? this.userMedia?.getAudioSampleRate();
                 }
                 stop(params) {
+                    this.cancelCameraRecovery();
                     if (!this.userMedia) throw new Error("No user media defined, unable to stop");
                     this.options.logger.debug(`Recorder: stop(${params ? string_pretty(params) : ""})`);
                     this.recordingActive = false;
@@ -20635,7 +20707,7 @@
                         if (this.userMedia) this.recordingStats.videoTrackLabel = this.userMedia.getVideoTrackLabel();
                         if (isAudioEnabled(this.options) && this.userMedia) {
                             this.recordingStats.samplesCount = this.samplesCount;
-                            this.recordingStats.sampleRate = this.userMedia.getAudioSampleRate();
+                            this.recordingStats.sampleRate = this.recordingAudioSampleRate ?? this.userMedia.getAudioSampleRate();
                         }
                         this.writeCommand("stop", this.recordingStats, ()=>{
                             this.emit("STOPPED", {
@@ -20690,6 +20762,7 @@
                     this.built = this.connecting = this.connected = false;
                 }
                 reset() {
+                    this.cancelCameraRecovery();
                     if (!this.unloaded) {
                         this.options.logger.debug("Recorder: reset()");
                         this.emit("RESETTING");
@@ -20717,7 +20790,70 @@
                 isReady() {
                     return this.userMedia?.isReady();
                 }
+                finishCameraRecovery(restored) {
+                    this.clearUserMediaTimeout();
+                    const resolve = this.resolveCameraRecovery;
+                    const resumeRequested = restored && this.resumeAfterCameraRecovery;
+                    this.cameraRecovery = void 0;
+                    this.resolveCameraRecovery = void 0;
+                    this.resumeAfterCameraRecovery = false;
+                    resolve?.(restored);
+                    if (resumeRequested && this.isPaused()) this.resume();
+                }
+                cancelCameraRecovery() {
+                    if (!this.cameraRecovery) return;
+                    this.mediaRequestId++;
+                    this.userMediaLoading = false;
+                    this.userMediaLoaded = false;
+                    this.clearUserMediaTimeout();
+                    this.userMedia?.stop(void 0, {
+                        preserveRecordingState: true
+                    });
+                    this.finishCameraRecovery(false);
+                }
+                failCameraRecovery(exc) {
+                    this.cancelCameraRecovery();
+                    const err = error_createError({
+                        message: "Camera recovery failed",
+                        explanation: "Your recording is still paused. Check camera permissions, then try Resume again or stop to keep the recorded part.",
+                        exc,
+                        options: this.options
+                    });
+                    this.emit("CAMERA_RECOVERY_FAILED", {
+                        err
+                    });
+                }
+                recoverCamera() {
+                    if (this.cameraRecovery) return this.cameraRecovery;
+                    if (!this.built || this.unloaded || !this.userMedia || this.userMediaLoading || this.submitting || this.key || void 0 !== this.stopTimeout || this.recordingTransportFailed) return Promise.resolve(false);
+                    const liveStream = this.userMedia.hasLiveStream();
+                    if (liveStream && this.isRecording()) return Promise.resolve(true);
+                    if (!liveStream && this.recordingActive && !this.isPaused()) this.pause();
+                    const recovery = new Promise((resolve)=>{
+                        this.resolveCameraRecovery = resolve;
+                    });
+                    this.cameraRecovery = recovery;
+                    this.emit("CAMERA_RECOVERING");
+                    if (liveStream) {
+                        this.userMediaTimeout = window.setTimeout(()=>{
+                            this.failCameraRecovery(new Error("Camera playback recovery timed out."));
+                        }, this.options.timeouts.userMedia);
+                        this.userMedia.restorePlayback().then(()=>{
+                            if (this.cameraRecovery === recovery) this.finishCameraRecovery(true);
+                        }).catch((exc)=>{
+                            if (this.cameraRecovery === recovery) this.failCameraRecovery(exc);
+                        });
+                    } else {
+                        this.userMediaLoaded = false;
+                        this.loadUserMedia({
+                            recovering: true
+                        });
+                    }
+                    return recovery;
+                }
                 pause(params) {
+                    this.cancelCameraRecovery();
+                    this.resumeAfterDrain = false;
                     if (params) this.options.logger.debug(`pause() at frame ${this.framesCount} with ${string_pretty(params)}`);
                     else this.options.logger.debug(`pause() at frame ${this.framesCount}`);
                     this.userMedia?.pause();
@@ -20726,10 +20862,15 @@
                     this.sendPings();
                 }
                 resume() {
+                    if (this.cameraRecovery || !this.userMedia?.hasLiveStream()) {
+                        this.recoverCamera();
+                        this.resumeAfterCameraRecovery = Boolean(this.cameraRecovery);
+                        return;
+                    }
                     this.options.logger.debug(`Recorder: resume() with frame ${this.framesCount}`);
                     this.stopPings();
                     this.emit("RESUMING");
-                    this.userMedia?.resume();
+                    this.userMedia.resume();
                     if (this.streamBackpressured) this.resumeAfterDrain = true;
                     else this.loop.start();
                 }
@@ -20784,7 +20925,7 @@
                     return newLoop;
                 }
                 record() {
-                    if (this.unloaded) return;
+                    if (this.unloaded || this.cameraRecovery) return;
                     if (!this.connected) {
                         this.options.logger.debug("Recorder: reconnecting before recording …");
                         this.initSocket(()=>{
@@ -20857,6 +20998,7 @@
                     this.recordingActive = true;
                     this.recordingTransportFailed = false;
                     this.mediaTransmissionStarted = false;
+                    this.recordingAudioSampleRate = void 0;
                     this.userMedia.record();
                     this.emit("RECORDING", {
                         framesCount: this.framesCount
@@ -20918,7 +21060,7 @@
                     }
                 }
                 switchFacingMode() {
-                    if (!util_getBrowser(this.options).isMobile()) return;
+                    if (this.cameraRecovery || !util_getBrowser(this.options).isMobile()) return;
                     if ("user" === this.facingMode) this.facingMode = "environment";
                     else if ("environment" === this.facingMode) this.facingMode = "user";
                     else this.options.logger.warn(`Recorder: unsupported facing mode ${string_pretty(this.facingMode)}`);
@@ -20929,12 +21071,14 @@
                 initEvents() {
                     this.options.logger.debug("Recorder: initEvents()");
                     this.on("SUBMITTING", ()=>{
+                        this.cancelCameraRecovery();
                         this.submitting = true;
                     });
                     this.on("SUBMITTED", ()=>{
                         this.submitting = false;
                     });
                     this.on("BLOCKING", ()=>{
+                        this.cancelCameraRecovery();
                         this.blocking = true;
                         this.clearUserMediaTimeout();
                     });
@@ -21362,6 +21506,7 @@
                 notifier;
                 visualsElement;
                 built = false;
+                cameraRecoveryFailed = false;
                 constructor(container, options){
                     super("Visuals", options);
                     this.container = container;
@@ -21396,6 +21541,17 @@
                             this.endWaiting();
                             this.container.enableForm(false);
                         });
+                        this.on("CAMERA_RECOVERING", ()=>{
+                            this.clearCameraRecoveryNotice();
+                        });
+                        this.on("CAMERA_RECOVERY_FAILED", ({ err })=>{
+                            this.cameraRecoveryFailed = true;
+                            this.options.logger.warn(err);
+                            if (this.options.displayErrors) this.notifier.notify(err.message, err.explanation, {
+                                problem: true
+                            });
+                            this.endWaiting();
+                        });
                         this.on("PREVIEW", ()=>{
                             this.endWaiting();
                         });
@@ -21474,6 +21630,7 @@
                     child.remove();
                 }
                 reset() {
+                    this.clearCameraRecoveryNotice();
                     this.endWaiting();
                     this.recorder.reset();
                 }
@@ -21484,11 +21641,13 @@
                     this.container.endWaiting();
                 }
                 stop(params) {
+                    this.clearCameraRecoveryNotice();
                     this.recorder.stop(params);
                     this.recorderInsides.hidePause();
                 }
                 back(keepHidden = false, cb) {
                     this.options.logger.debug(`Visuals: back(keepHidden = ${keepHidden})`);
+                    this.cameraRecoveryFailed = false;
                     this.replay.hide();
                     this.notifier.hide();
                     if (keepHidden) {
@@ -21510,6 +21669,7 @@
                     if (!this.built) return;
                     const e = params?.e;
                     this.options.logger.debug(`Visuals: unload(${e ? string_pretty(e) : ""})`);
+                    this.cameraRecoveryFailed = false;
                     this.recorder.unload(params);
                     this.recorderInsides.unload();
                     this.replay.unload(params);
@@ -21523,13 +21683,31 @@
                     this.recorder.pause(params);
                     this.recorderInsides.showPause();
                 }
+                clearCameraRecoveryNotice() {
+                    if (this.cameraRecoveryFailed) {
+                        this.notifier.hide();
+                        this.recorder.show();
+                        this.cameraRecoveryFailed = false;
+                    }
+                }
+                recoverCamera() {
+                    if (this.replay.isShown() || this.isNotifying() && !this.cameraRecoveryFailed) return Promise.resolve(false);
+                    this.clearCameraRecoveryNotice();
+                    return this.recorder.recoverCamera();
+                }
                 resume() {
-                    if (this.recorderInsides.isCountingDown()) this.recorderInsides.resumeCountdown();
-                    else this.recorder.resume();
-                    this.recorderInsides.hidePause();
+                    this.clearCameraRecoveryNotice();
+                    if (this.recorderInsides.isCountingDown()) {
+                        this.recorderInsides.resumeCountdown();
+                        this.recorderInsides.hidePause();
+                    } else {
+                        this.recorder.resume();
+                        if (!this.recorder.isPaused()) this.recorderInsides.hidePause();
+                    }
                 }
                 pauseOrResume() {
-                    if (this.isRecordable()) {
+                    if (this.cameraRecoveryFailed && this.recorder.isPaused()) this.resume();
+                    else if (this.isRecordable()) {
                         if (this.isRecording()) this.pause();
                         else if (this.recorder.isPaused()) this.resume();
                         else if (this.recorder.isReady()) this.recorder.record();
@@ -21772,10 +21950,10 @@
                     });
                     if (!playerOnly) this.stopListeningToVisibility = this.visibility.onChange((visible)=>{
                         if (this.built) if (visible) {
-                            if (isAutoPauseEnabled(this.options) && this.isCountingDown()) this.resume();
+                            if (isAutoPauseEnabled(this.options)) this.recoverCamera();
                             this.emit("VISIBLE");
                         } else {
-                            if (isAutoPauseEnabled(this.options) && (this.isCountingDown() || this.isRecording())) this.pause();
+                            if (isAutoPauseEnabled(this.options)) this.suspend();
                             this.emit("INVISIBLE");
                         }
                     });
@@ -21963,6 +22141,13 @@
                 pause(params) {
                     this.visuals.pause(params);
                 }
+                suspend() {
+                    if (this.built && (this.isCountingDown() || this.isRecording() || this.isPaused())) this.pause();
+                }
+                recoverCamera() {
+                    if (!this.built || this.hasError || this.submitted) return Promise.resolve(false);
+                    return this.visuals.recoverCamera();
+                }
                 validate(event, force = false) {
                     let runValidation = true;
                     let valid = true;
@@ -22281,6 +22466,12 @@
                 record() {
                     this.container.record();
                 }
+                pause() {
+                    this.container.suspend();
+                }
+                recoverCamera() {
+                    return this.container.recoverCamera();
+                }
                 getLogLines() {
                     if (this.options.logger.getLines) return this.options.logger.getLines();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "videomail-client",
-  "version": "16.0.3",
+  "version": "16.1.0",
   "description": "A wicked npm package to record videos directly in the browser, for Deaf and Sign Language!",
   "keywords": [
     "webcam",