A platform for community discussion. Free, open, simple.
FEATURE: Restore preferred voice camera (#43252)
Samfe397de51287
diff --git a/plugins/voice/assets/javascripts/discourse/app/services/voice-webrtc.js b/plugins/voice/assets/javascripts/discourse/app/services/voice-webrtc.jsindex 0dbfed1d26b..9e7864aad22 100644--- a/plugins/voice/assets/javascripts/discourse/app/services/voice-webrtc.js+++ b/plugins/voice/assets/javascripts/discourse/app/services/voice-webrtc.js@@ -61,8 +61,11 @@ import {import TranscriptionCoordinator from "../../lib/voice/transcription-coordinator";import { applyVoiceQuality } from "../../lib/voice/video-quality";+const CAMERA_ENABLED_KEY_PREFIX = "voice-camera-enabled";+export default class VoiceWebrtcService extends Service {@service currentUser;+ @service keyValueStore;@service messageBus;@service modal;@service siteSettings;@@ -111,6 +114,8 @@ export default class VoiceWebrtcService extends Service {#roomHandlerCallbacks = new Map();#deferredTeardownTimers = new Set();#pendingPlaybackElements = new WeakSet();+ #cameraRestorePromise = null;+ #queuedCameraRestoreRoomId = null;#signaling;#peerManager;@@ -286,6 +291,11 @@ export default class VoiceWebrtcService extends Service {this.currentUser?.id,state),+ onScreenShareEnded: () => {+ if (this.watchingRoomId) {+ this.#restorePreferredCamera(this.watchingRoomId);+ }+ },showError: (messageKey) =>this.toasts.error({duration: 5000,@@ -419,6 +429,9 @@ export default class VoiceWebrtcService extends Service {this.#livekit.destroy();this.#signaling.destroy();+ this.watchingRoomId = null;+ this.#cameraRestorePromise = null;+ this.#queuedCameraRestoreRoomId = null;this.#localVideo.destroy();this.#localAudio.stop();this.#transcription.destroy();@@ -634,6 +647,86 @@ export default class VoiceWebrtcService extends Service {return (this.#roomTransports.get(roomId) ?? "mesh") === "mesh";}+ #cameraEnabledKey(userId) {+ return `${CAMERA_ENABLED_KEY_PREFIX}-${userId}`;+ }++ #cameraPreferred(userId = this.currentUser?.id) {+ if (!userId) {+ return false;+ }++ try {+ return this.keyValueStore.get(this.#cameraEnabledKey(userId)) === "true";+ } catch {+ return false;+ }+ }++ #setCameraPreferred(enabled, userId = this.currentUser?.id) {+ if (!userId) {+ return;+ }++ try {+ if (enabled) {+ this.keyValueStore.set({+ key: this.#cameraEnabledKey(userId),+ value: "true",+ });+ } else {+ this.keyValueStore.remove(this.#cameraEnabledKey(userId));+ }+ } catch {+ // A storage failure must not interfere with the camera control.+ }+ }++ #restorePreferredCamera(roomId) {+ const userId = this.currentUser?.id;+ if (+ this.#cameraRestorePromise ||+ !this.#activeRoomIds.has(roomId) ||+ this.watchingRoomId !== roomId ||+ this.localVideoKind ||+ !this.#cameraPreferred(userId) ||+ !this.canPublishVideo(roomId)+ ) {+ return;+ }++ const restorePromise = this.#localVideo+ .start("camera", {+ silent: true,+ shouldContinue: () =>+ this.currentUser?.id === userId &&+ this.#activeRoomIds.has(roomId) &&+ this.watchingRoomId === roomId &&+ (!this.localVideoKind || this.localVideoKind === "camera") &&+ this.#cameraPreferred(userId) &&+ this.canPublishVideo(roomId),+ })+ .catch((error) => {+ // eslint-disable-next-line no-console+ console.warn("[voice] failed to restore preferred camera state", error);+ });+ this.#cameraRestorePromise = restorePromise;++ restorePromise.finally(() => {+ if (this.#cameraRestorePromise === restorePromise) {+ this.#cameraRestorePromise = null;+ }++ const queuedRoomId = this.#queuedCameraRestoreRoomId;+ this.#queuedCameraRestoreRoomId = null;+ if (queuedRoomId && this.watchingRoomId === queuedRoomId) {+ this.#restorePreferredCamera(queuedRoomId);+ } else if (this.watchingRoomId && this.watchingRoomId !== roomId) {+ this.#restorePreferredCamera(this.watchingRoomId);+ }+ });+ }+isLivekitRoom(roomId) {return this.#roomTransports.get(roomId) === "livekit";}@@ -1224,12 +1317,41 @@ export default class VoiceWebrtcService extends Service {return this.#localVideo.inputDeviceId;}- toggleCamera() {- return this.#localVideo.toggleCamera();+ async toggleCamera() {+ const userId = this.currentUser?.id;+ if (!this.localVideoKind && this.#cameraRestorePromise) {+ this.#setCameraPreferred(false, userId);+ this.#queuedCameraRestoreRoomId = null;+ await this.#cameraRestorePromise;+ if (this.localVideoKind === "camera") {+ await this.#localVideo.stop();+ }+ return;+ }++ const cameraWasActive = this.localVideoKind === "camera";+ if (cameraWasActive) {+ this.#setCameraPreferred(false, userId);+ }++ const result = await this.#localVideo.toggleCamera();++ if (!cameraWasActive && this.localVideoKind === "camera") {+ this.#setCameraPreferred(true, userId);+ }++ return result;}- toggleScreenShare() {- return this.#localVideo.toggleScreenShare();+ async toggleScreenShare() {+ const screenWasActive = this.localVideoKind === "screen";+ const result = await this.#localVideo.toggleScreenShare();++ if (screenWasActive && !this.localVideoKind && this.watchingRoomId) {+ this.#restorePreferredCamera(this.watchingRoomId);+ }++ return result;}toggleVideoBlur() {@@ -1304,6 +1426,15 @@ export default class VoiceWebrtcService extends Service {if (!this.#isMeshRoom(roomId)) {this.#livekit.sessionFor(roomId)?.setVideoSubscriptionsEnabled(watching);}++ if (watching) {+ if (this.#cameraRestorePromise) {+ this.#queuedCameraRestoreRoomId = roomId;+ }+ this.#restorePreferredCamera(roomId);+ } else if (this.#queuedCameraRestoreRoomId === roomId) {+ this.#queuedCameraRestoreRoomId = null;+ }}@actiondiff --git a/plugins/voice/assets/javascripts/discourse/lib/voice/local-video-manager.js b/plugins/voice/assets/javascripts/discourse/lib/voice/local-video-manager.jsindex 1dec8a72fbd..649e34899b2 100644--- a/plugins/voice/assets/javascripts/discourse/lib/voice/local-video-manager.js+++ b/plugins/voice/assets/javascripts/discourse/lib/voice/local-video-manager.js@@ -52,6 +52,7 @@ export default class LocalVideoManager {#isBlurAllowed;#setParticipantVideoState;#showError;+ #onScreenShareEnded;constructor(options) {this.#peerManager = options.peerManager;@@ -71,6 +72,7 @@ export default class LocalVideoManager {this.#isBlurAllowed = options.isBlurAllowed;this.#setParticipantVideoState = options.setParticipantVideoState;this.#showError = options.showError;+ this.#onScreenShareEnded = options.onScreenShareEnded;}get blurSupported() {@@ -207,10 +209,12 @@ export default class LocalVideoManager {}}- #revertBlurPreference() {+ #revertBlurPreference({ silent = false } = {}) {this.blurEnabled = false;BackgroundBlurManager.setPreference(false);- this.#showError("voice.video_settings.blur_failed");+ if (!silent) {+ this.#showError("voice.video_settings.blur_failed");+ }}setBlurAmount(value) {@@ -334,9 +338,6 @@ export default class LocalVideoManager {}track.contentHint = "motion";- track.addEventListener("ended", () => this.#handleTrackEnded(), {- once: true,- });const oldStream = this.stream;const oldRaw = this.#rawStream;@@ -369,6 +370,13 @@ export default class LocalVideoManager {this.#rawStream = blurResult ? newStream : null;this.stream = outgoingStream;+ const swappedEpoch = ++this.#epoch;+ track.addEventListener(+ "ended",+ () => this.#handleTrackEnded(swappedEpoch, "camera"),+ { once: true }+ );+oldStream?.getTracks().forEach((streamTrack) => streamTrack.stop());if (oldRaw && oldRaw !== oldStream) {oldRaw.getTracks().forEach((streamTrack) => streamTrack.stop());@@ -414,14 +422,16 @@ export default class LocalVideoManager {}}- async start(kind) {+ async start(kind, { shouldContinue, silent = false } = {}) {const roomId = this.#getFirstActiveRoomId();if (!roomId) {return;}if (!this.#canPublishVideo(roomId)) {- this.#showError("voice.video.publisher_limit");+ if (!silent) {+ this.#showError("voice.video.publisher_limit");+ }return;}@@ -461,14 +471,18 @@ export default class LocalVideoManager {} catch (error) {// eslint-disable-next-line no-consoleconsole.warn(`[voice] failed to obtain ${kind} stream`, error);- if (error?.name !== "NotAllowedError" && error?.name !== "AbortError") {+ if (+ !silent &&+ error?.name !== "NotAllowedError" &&+ error?.name !== "AbortError"+ ) {this.#showError("voice.video.capture_failed");}return;}// The user may have left the room while the capture picker was open.- if (!this.#isActiveRoom(roomId)) {+ if (!this.#isActiveRoom(roomId) || (shouldContinue && !shouldContinue())) {stream.getTracks().forEach((streamTrack) => streamTrack.stop());return;}@@ -495,7 +509,7 @@ export default class LocalVideoManager {const epoch = ++this.#epoch;track.contentHint = kind === "screen" ? "detail" : "motion";- track.addEventListener("ended", () => this.#handleTrackEnded(), {+ track.addEventListener("ended", () => this.#handleTrackEnded(epoch, kind), {once: true,});@@ -514,7 +528,11 @@ export default class LocalVideoManager {) {const result = await this.#createBackgroundBlur(stream);- if (epoch !== this.#epoch || !this.#isActiveRoom(roomId)) {+ if (+ epoch !== this.#epoch ||+ !this.#isActiveRoom(roomId) ||+ (shouldContinue && !shouldContinue())+ ) {result?.manager.teardown();stream.getTracks().forEach((streamTrack) => streamTrack.stop());return;@@ -525,7 +543,7 @@ export default class LocalVideoManager {this.#rawStream = stream;outgoingStream = result.processed;} else {- this.#revertBlurPreference();+ this.#revertBlurPreference({ silent });}}@@ -536,12 +554,30 @@ export default class LocalVideoManager {await this.#broadcastState(roomId);} catch (error) {await this.stop({ broadcast: false });- popupAjaxError(error);+ if (!silent) {+ popupAjaxError(error);+ }+ return;+ }++ if (!this.#ownsPipeline(epoch, outgoingStream, kind)) {+ return;+ }+ if (shouldContinue && !shouldContinue()) {+ await this.stop();return;}await this.syncSenders(roomId);+ if (!this.#ownsPipeline(epoch, outgoingStream, kind)) {+ return;+ }+ if (shouldContinue && !shouldContinue()) {+ await this.stop();+ return;+ }+// Applies any blur preference change that raced this startup (e.g. the// toggle was flipped while the model loaded for the initial wrap).this.#enqueueOp(() => this.#reconcileBlurOp());@@ -563,19 +599,31 @@ export default class LocalVideoManager {if (roomId) {await this.syncSenders(roomId);if (broadcast) {- this.#broadcastState(roomId).catch(() => {});+ await this.#broadcastState(roomId).catch(() => {});}}}- #handleTrackEnded() {- if (!this.kind) {+ #ownsPipeline(epoch, stream, kind) {+ return (+ epoch === this.#epoch && this.stream === stream && this.kind === kind+ );+ }++ #handleTrackEnded(epoch, endedKind) {+ if (epoch !== this.#epoch || endedKind !== this.kind) {return;}- this.stop().catch((error) => {- // eslint-disable-next-line no-console- console.warn("[voice] failed to stop local video", error);- });+ this.stop()+ .then(() => {+ if (endedKind === "screen") {+ this.#onScreenShareEnded?.();+ }+ })+ .catch((error) => {+ // eslint-disable-next-line no-console+ console.warn("[voice] failed to stop local video", error);+ });}#applyContentHint() {diff --git a/plugins/voice/test/javascripts/unit/services/voice-webrtc-livekit-test.js b/plugins/voice/test/javascripts/unit/services/voice-webrtc-livekit-test.jsindex 6cf79f56e21..1807b1b8c65 100644--- a/plugins/voice/test/javascripts/unit/services/voice-webrtc-livekit-test.js+++ b/plugins/voice/test/javascripts/unit/services/voice-webrtc-livekit-test.js@@ -486,6 +486,9 @@ module("Voice | Unit | Service | voice-webrtc-livekit", function (hooks) {setPeerTimingForTesting(SAFE_PEER_TIMING);this.currentUser = logIn(this.owner);this.currentUser.id = 10;+ this.keyValueStore = this.owner.lookup("service:key-value-store");+ this.cameraPreferenceKey = `voice-camera-enabled-${this.currentUser.id}`;+ this.keyValueStore.remove(this.cameraPreferenceKey);this.siteSettings = this.owner.lookup("service:site-settings");this.siteSettings.voice_auto_status_enabled = true;this.siteSettings.voice_video_enabled = true;@@ -612,6 +615,7 @@ module("Voice | Unit | Service | voice-webrtc-livekit", function (hooks) {hooks.afterEach(function () {this.subject?.leave({ id: 1 }, { keepLocalStream: true });+ this.keyValueStore.remove(this.cameraPreferenceKey);setPeerTimingForTesting(null);setLivekitSdkLoaderForTesting(null);@@ -997,6 +1001,35 @@ module("Voice | Unit | Service | voice-webrtc-livekit", function (hooks) {);});+ test("a remembered camera publishes after the LiveKit call becomes visible", async function (assert) {+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await waitUntil(() =>+ this.stateRequests.some(({ video }) => video === "true")+ );++ const lkRoom = this.FakeLivekitRoom.instances[0];+ const publication = lkRoom.localParticipant.published.find(+ ({ track }) => track.mediaStreamTrack === this.cameraTrack+ );++ assert.notStrictEqual(+ publication,+ undefined,+ "publishes the remembered camera track"+ );+ assert.deepEqual(+ this.stateRequests.at(-1),+ { video: "true", screen: "false" },+ "broadcasts the restored camera state"+ );+ });+test("toggleCamera publishes a simulcast camera track and broadcasts state", async function (assert) {await this.subject.join(this.room);await wait(50);diff --git a/plugins/voice/test/javascripts/unit/services/voice-webrtc-test.js b/plugins/voice/test/javascripts/unit/services/voice-webrtc-test.jsindex 5ce24361f13..83e384802bd 100644--- a/plugins/voice/test/javascripts/unit/services/voice-webrtc-test.js+++ b/plugins/voice/test/javascripts/unit/services/voice-webrtc-test.js@@ -99,7 +99,12 @@ class VoiceRoomsStub extends Service {}class ToastsStub extends Service {- error() {}+ errors = [];++ error(options) {+ this.errors.push(options);+ }+success() {}default() {}}@@ -462,6 +467,9 @@ module("Voice | Unit | Service | voice-webrtc", function (hooks) {hooks.beforeEach(function () {setPeerTimingForTesting(SAFE_PEER_TIMING);this.currentUser = logIn(this.owner);+ this.keyValueStore = this.owner.lookup("service:key-value-store");+ this.cameraPreferenceKey = `voice-camera-enabled-${this.currentUser.id}`;+ this.keyValueStore.remove(this.cameraPreferenceKey);this.siteSettings = this.owner.lookup("service:site-settings");this.siteSettings.voice_auto_status_enabled = true;localStorage.removeItem("voice:noise-suppression");@@ -547,6 +555,7 @@ module("Voice | Unit | Service | voice-webrtc", function (hooks) {hooks.afterEach(function () {this.subject?.leave({ id: 1 }, { keepLocalStream: true });+ this.keyValueStore.remove(this.cameraPreferenceKey);setPeerTimingForTesting(null);globalThis.RTCPeerConnection = this.originalRTCPeerConnection;@@ -2184,6 +2193,18 @@ module("Voice | Unit | Service | voice-webrtc", function (hooks) {};}+ function createEndableCameraTrack(id) {+ const track = createFakeCameraTrack(id);+ let ended;+ track.addEventListener = (event, callback) => {+ if (event === "ended") {+ ended = callback;+ }+ };+ track.end = () => ended?.();+ return track;+ }+function createFakeCameraStream(id, track) {return {id,@@ -2206,6 +2227,686 @@ module("Voice | Unit | Service | voice-webrtc", function (hooks) {pretender.post("/voice/rooms/1/state", () => response({}));}+ test("explicit camera toggles update the remembered preference", async function (assert) {+ setupCameraRoom(this);++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ const cameraTrack = createFakeCameraTrack("camera-track");+ const cameraStream = createFakeCameraStream("camera-stream", cameraTrack);+ navigator.mediaDevices.getUserMedia = async (constraints) =>+ constraints?.video ? cameraStream : rawStream;++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);++ await this.subject.toggleCamera();++ assert.strictEqual(+ this.keyValueStore.get(this.cameraPreferenceKey),+ "true",+ "remembers a successfully started camera"+ );++ await this.subject.toggleCamera();++ assert.strictEqual(+ this.keyValueStore.get(this.cameraPreferenceKey),+ undefined,+ "clears the preference when the user turns the camera off"+ );+ } finally {+ audioEnvironment.restore();+ }+ });++ test("a remembered camera restarts after leaving and joining another watched room", async function (assert) {+ setupCameraRoom(this);++ const secondRoom = {+ ...this.room,+ id: 2,+ name: "Second room",+ active_participants: [{ id: this.currentUser.id, role: "participant" }],+ };+ this.rooms.seedRoom(secondRoom);+ pretender.post("/voice/rooms/2/join", () =>+ response({+ participant_session_id: "session-def",+ room: JSON.parse(JSON.stringify(secondRoom)),+ })+ );+ pretender.post("/voice/rooms/2/state", () => response({}));+ pretender.delete("/voice/rooms/2/leave", () => response({}));++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ const cameraTracks = [];+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (!constraints?.video) {+ return rawStream;+ }++ const track = createFakeCameraTrack(+ `camera-track-${cameraTracks.length}`+ );+ cameraTracks.push(track);+ return createFakeCameraStream(+ `camera-stream-${cameraTracks.length}`,+ track+ );+ };++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await this.subject.toggleCamera();++ this.subject.leave(this.room, { keepLocalStream: true });++ assert.true(+ cameraTracks[0].stopped,+ "releases the first room's camera track while preserving intent"+ );++ await this.subject.join(secondRoom);+ this.subject.setWatching(2, true);+ await waitUntil(() => this.subject.localVideoKind === "camera");++ assert.strictEqual(+ cameraTracks.length,+ 2,+ "acquires a fresh camera stream without another camera-button click"+ );+ assert.strictEqual(+ this.keyValueStore.get(this.cameraPreferenceKey),+ "true",+ "keeps the remembered camera preference"+ );+ } finally {+ this.subject.leave(secondRoom, { keepLocalStream: true });+ audioEnvironment.restore();+ }+ });++ test("a remembered camera waits for a visible call surface", async function (assert) {+ setupCameraRoom(this);+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ let cameraCaptures = 0;+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (!constraints?.video) {+ return rawStream;+ }++ cameraCaptures++;+ const track = createFakeCameraTrack("camera-track");+ return createFakeCameraStream("camera-stream", track);+ };++ try {+ await this.subject.join(this.room);+ await wait(20);++ assert.strictEqual(+ cameraCaptures,+ 0,+ "does not capture while the room has no visible controls"+ );++ this.subject.setWatching(1, true);+ await waitUntil(() => this.subject.localVideoKind === "camera");++ assert.strictEqual(+ cameraCaptures,+ 1,+ "captures after the room page or call widget becomes visible"+ );+ } finally {+ audioEnvironment.restore();+ }+ });++ test("a pending camera restore is deduplicated and canceled when its controls disappear", async function (assert) {+ setupCameraRoom(this);+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ const cameraGranted = deferred();+ const cameraTrack = createFakeCameraTrack("camera-track");+ const cameraStream = createFakeCameraStream("camera-stream", cameraTrack);+ let cameraCaptures = 0;+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (!constraints?.video) {+ return rawStream;+ }++ cameraCaptures++;+ return cameraGranted.promise;+ };++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ this.subject.setWatching(1, true);+ await waitUntil(() => cameraCaptures === 1);++ this.subject.setWatching(1, false);+ cameraGranted.resolve(cameraStream);+ await waitUntil(() => cameraTrack.stopped);++ assert.strictEqual(+ cameraCaptures,+ 1,+ "uses one capture request for repeated watching updates"+ );+ assert.strictEqual(+ this.subject.localVideoKind,+ null,+ "does not publish after the visible controls disappear"+ );+ } finally {+ audioEnvironment.restore();+ }+ });++ test("an in-flight camera restore does not replace an explicit screen share", async function (assert) {+ setupCameraRoom(this);+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ const cameraGranted = deferred();+ const cameraTrack = createFakeCameraTrack("camera-track");+ const cameraStream = createFakeCameraStream("camera-stream", cameraTrack);+ const screenTrack = createFakeCameraTrack("screen-track");+ const screenStream = {+ ...createFakeCameraStream("screen-stream", screenTrack),+ getAudioTracks: () => [],+ };+ const originalGetDisplayMedia = navigator.mediaDevices.getDisplayMedia;+ navigator.mediaDevices.getUserMedia = async (constraints) =>+ constraints?.video ? cameraGranted.promise : rawStream;+ navigator.mediaDevices.getDisplayMedia = async () => screenStream;++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await this.subject.toggleScreenShare();++ cameraGranted.resolve(cameraStream);+ await waitUntil(() => cameraTrack.stopped);++ assert.strictEqual(+ this.subject.localVideoKind,+ "screen",+ "keeps the explicitly selected screen share active"+ );+ assert.false(+ screenTrack.stopped,+ "does not stop the screen track when camera capture resolves"+ );+ } finally {+ if (originalGetDisplayMedia) {+ navigator.mediaDevices.getDisplayMedia = originalGetDisplayMedia;+ } else {+ delete navigator.mediaDevices.getDisplayMedia;+ }+ audioEnvironment.restore();+ }+ });++ test("stopping a screen share restores the previously enabled camera", async function (assert) {+ setupCameraRoom(this);++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ const cameraTracks = [];+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (!constraints?.video) {+ return rawStream;+ }++ const track = createFakeCameraTrack(+ `camera-track-${cameraTracks.length}`+ );+ cameraTracks.push(track);+ return createFakeCameraStream(+ `camera-stream-${cameraTracks.length}`,+ track+ );+ };+ const screenTrack = createFakeCameraTrack("screen-track");+ const screenStream = {+ ...createFakeCameraStream("screen-stream", screenTrack),+ getAudioTracks: () => [],+ };+ const originalGetDisplayMedia = navigator.mediaDevices.getDisplayMedia;+ navigator.mediaDevices.getDisplayMedia = async () => screenStream;++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await this.subject.toggleCamera();+ await this.subject.toggleScreenShare();++ assert.strictEqual(+ this.subject.localVideoKind,+ "screen",+ "replaces the camera with the screen share"+ );++ await this.subject.toggleScreenShare();+ await waitUntil(() => this.subject.localVideoKind === "camera");++ assert.strictEqual(+ cameraTracks.length,+ 2,+ "reacquires the camera after screen sharing stops"+ );+ } finally {+ if (originalGetDisplayMedia) {+ navigator.mediaDevices.getDisplayMedia = originalGetDisplayMedia;+ } else {+ delete navigator.mediaDevices.getDisplayMedia;+ }+ audioEnvironment.restore();+ }+ });++ test("stopping a screen share keeps a previously disabled camera off", async function (assert) {+ setupCameraRoom(this);++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ let cameraCaptures = 0;+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (constraints?.video) {+ cameraCaptures++;+ }+ return rawStream;+ };+ const screenTrack = createFakeCameraTrack("screen-track");+ const screenStream = {+ ...createFakeCameraStream("screen-stream", screenTrack),+ getAudioTracks: () => [],+ };+ const originalGetDisplayMedia = navigator.mediaDevices.getDisplayMedia;+ navigator.mediaDevices.getDisplayMedia = async () => screenStream;++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await this.subject.toggleScreenShare();+ await this.subject.toggleScreenShare();+ await wait(20);++ assert.strictEqual(+ cameraCaptures,+ 0,+ "does not acquire a camera without a remembered camera-on choice"+ );+ assert.strictEqual(this.subject.localVideoKind, null, "leaves video off");+ } finally {+ if (originalGetDisplayMedia) {+ navigator.mediaDevices.getDisplayMedia = originalGetDisplayMedia;+ } else {+ delete navigator.mediaDevices.getDisplayMedia;+ }+ audioEnvironment.restore();+ }+ });++ test("the browser's stop-sharing action restores the previously enabled camera", async function (assert) {+ setupCameraRoom(this);++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ let cameraCaptures = 0;+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (!constraints?.video) {+ return rawStream;+ }++ cameraCaptures++;+ const track = createFakeCameraTrack(`camera-track-${cameraCaptures}`);+ return createFakeCameraStream(`camera-stream-${cameraCaptures}`, track);+ };+ const screenTrack = createEndableCameraTrack("screen-track");+ const screenStream = {+ ...createFakeCameraStream("screen-stream", screenTrack),+ getAudioTracks: () => [],+ };+ const originalGetDisplayMedia = navigator.mediaDevices.getDisplayMedia;+ navigator.mediaDevices.getDisplayMedia = async () => screenStream;++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await this.subject.toggleCamera();+ await this.subject.toggleScreenShare();++ screenTrack.end();+ await waitUntil(+ () => this.subject.localVideoKind === "camera" && cameraCaptures === 2+ );++ assert.strictEqual(+ this.subject.localVideoKind,+ "camera",+ "restores the camera after the browser ends screen capture"+ );+ } finally {+ if (originalGetDisplayMedia) {+ navigator.mediaDevices.getDisplayMedia = originalGetDisplayMedia;+ } else {+ delete navigator.mediaDevices.getDisplayMedia;+ }+ audioEnvironment.restore();+ }+ });++ test("a delayed ended event cannot stop a replacement screen share", async function (assert) {+ setupCameraRoom(this);++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ const cameraTrack = createEndableCameraTrack("camera-track");+ const cameraStream = createFakeCameraStream("camera-stream", cameraTrack);+ navigator.mediaDevices.getUserMedia = async (constraints) =>+ constraints?.video ? cameraStream : rawStream;+ const screenTrack = createFakeCameraTrack("screen-track");+ const screenStream = {+ ...createFakeCameraStream("screen-stream", screenTrack),+ getAudioTracks: () => [],+ };+ const originalGetDisplayMedia = navigator.mediaDevices.getDisplayMedia;+ navigator.mediaDevices.getDisplayMedia = async () => screenStream;++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await this.subject.toggleCamera();+ await this.subject.toggleScreenShare();++ cameraTrack.end();+ await wait(20);++ assert.strictEqual(+ this.subject.localVideoKind,+ "screen",+ "ignores an ended event from the replaced camera pipeline"+ );+ assert.false(+ screenTrack.stopped,+ "keeps the replacement screen track active"+ );+ } finally {+ if (originalGetDisplayMedia) {+ navigator.mediaDevices.getDisplayMedia = originalGetDisplayMedia;+ } else {+ delete navigator.mediaDevices.getDisplayMedia;+ }+ audioEnvironment.restore();+ }+ });++ test("a failed explicit camera start does not create a preference", async function (assert) {+ setupCameraRoom(this);++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (constraints?.video) {+ throw new DOMException("Permission denied", "NotAllowedError");+ }+ return rawStream;+ };++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await this.subject.toggleCamera();++ assert.strictEqual(+ this.keyValueStore.get(this.cameraPreferenceKey),+ undefined,+ "keeps future calls camera-off after capture is denied"+ );+ assert.strictEqual(+ this.subject.connectionStateFor(1),+ "connected",+ "keeps the audio call connected"+ );+ } finally {+ audioEnvironment.restore();+ }+ });++ test("a failed automatic camera restore stays silent", async function (assert) {+ setupCameraRoom(this);+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (constraints?.video) {+ throw new DOMException("Camera unavailable", "NotFoundError");+ }+ return rawStream;+ };++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await wait(20);++ const toasts = this.owner.lookup("service:toasts");+ assert.deepEqual(+ toasts.errors,+ [],+ "does not report a background capture failure as a user action"+ );+ } finally {+ audioEnvironment.restore();+ }+ });++ test("a watched room restores the camera when its join finishes", async function (assert) {+ setupCameraRoom(this);+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ let cameraCaptures = 0;+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (!constraints?.video) {+ return rawStream;+ }++ cameraCaptures++;+ const track = createFakeCameraTrack("camera-track");+ return createFakeCameraStream("camera-stream", track);+ };++ try {+ this.subject.setWatching(1, true);+ await this.subject.join(this.room);+ await waitUntil(() => this.subject.localVideoKind === "camera");++ assert.strictEqual(+ cameraCaptures,+ 1,+ "restores after joining a room whose page was already visible"+ );+ } finally {+ audioEnvironment.restore();+ }+ });++ test("a camera click cancels an in-flight automatic restore", async function (assert) {+ setupCameraRoom(this);+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ const cameraGranted = deferred();+ const cameraTrack = createFakeCameraTrack("camera-track");+ const cameraStream = createFakeCameraStream("camera-stream", cameraTrack);+ let cameraCaptures = 0;+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (!constraints?.video) {+ return rawStream;+ }++ cameraCaptures++;+ return cameraGranted.promise;+ };++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await waitUntil(() => cameraCaptures === 1);++ const toggle = this.subject.toggleCamera();+ cameraGranted.resolve(cameraStream);+ await toggle;++ assert.strictEqual(+ this.subject.localVideoKind,+ null,+ "keeps the camera off after the explicit click"+ );+ assert.true(+ cameraTrack.stopped,+ "releases the capture granted after cancellation"+ );+ assert.strictEqual(+ this.keyValueStore.get(this.cameraPreferenceKey),+ undefined,+ "remembers the explicit camera-off choice"+ );+ } finally {+ audioEnvironment.restore();+ }+ });++ test("a remembered camera does not bypass room video permissions", async function (assert) {+ setupCameraRoom(this);+ this.room.video_enabled = false;+ this.keyValueStore.set({+ key: this.cameraPreferenceKey,+ value: "true",+ });++ const rawTrack = createFakeTrack("raw-track");+ const rawStream = createFakeStream("raw-stream", rawTrack);+ const audioEnvironment = installFakeAudioEnvironment({+ rawStream,+ processedStream: rawStream,+ });+ let cameraCaptures = 0;+ navigator.mediaDevices.getUserMedia = async (constraints) => {+ if (constraints?.video) {+ cameraCaptures++;+ }+ return rawStream;+ };++ try {+ await this.subject.join(this.room);+ this.subject.setWatching(1, true);+ await wait(20);++ assert.strictEqual(+ cameraCaptures,+ 0,+ "does not acquire video in a room where publishing is forbidden"+ );+ assert.strictEqual(+ this.keyValueStore.get(this.cameraPreferenceKey),+ "true",+ "preserves the preference for a later eligible room"+ );+ } finally {+ audioEnvironment.restore();+ }+ });+test("setVideoInputDevice releases the live camera and retries when the hardware is busy", async function (assert) {setupCameraRoom(this);