Compare commits

...
Author SHA1 Message Date
renovate[bot] b2f7fccc6e Update ghcr.io/element-hq/element-web:develop Docker digest to 2f9e5d9 (#4490)
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
2026-11-21 02:07:47 +00:00
TimoandClaude Fable 5.2 f9dafcd5ea Publish late device (#4485)
* Publish a camera or microphone listed after the call view opened

Without a lobby the call decides what to publish once, as its view
mounts. A device the browser listed a moment later switched to its
default "on" without the mute handler being asked, so the button showed
on and nothing was published: the other side kept waiting for media.

The default is now asked of the handler like any other request where one
is set, so the call publishes the device. A device that comes back while
a handler is set stays off, since the user may have turned it off; the
button used to show it as on there too. Without a handler, as in the
lobby, the default is assumed at once as before.

Follows the patch tiran133 posted on the issue. A stop-gap until one
reconciler owns the local media.

Fixes https://github.com/element-hq/element-call/issues/4403

---------

Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-20 17:07:51 +00:00
Timo ded4471525 Merge pull request #4486 from element-hq/toger5/4479-exact-device-constraint
Exact device constraint (fixes chrome device switches)
2026-11-20 17:57:43 +01:00
Timo K. e74e83ab08 comments on what fixes the chrome issue 2026-11-20 17:15:41 +01:00
Johannes Marbach 3917bbb8f2 Merge pull request #4484 from ciefa/ciefa/fullscreen-button-clear-of-footer
Keep the tile buttons clear of the footer when it overlays the video
2026-11-20 15:33:43 +01:00
Timo K.andClaude Fable 5.2 4c66fe6f7d Ask the browser for the exact camera and microphone picked
Chromium hands back its default device for a deviceId that is only
preferred, so picking another camera reopened the same one: the preview
flashed and nothing changed. The lobby's own capture and the in-call
switch both passed the id as a preference since they stopped going
through LiveKit's track creation, which made it exact.

- The lobby media asks for the exact device, and falls back to the
  browser's choice only where the remembered device is gone.
- A track handed over to the call keeps the exact device, so that LiveKit
  reopens the same one after a mute.
- Switching the facing mode lets go of the pinned device.
- setDevice rejects where the track did not end up on the device, in the
  lobby and in the call, and keeps the track it had.

Fixes https://github.com/element-hq/element-call/issues/4479

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-20 14:07:17 +01:00
Johannes Marbach ffd6360277 Merge pull request #4472 from element-hq/johannes/stable-rtc-device
Request capability to receive m.rtc.encryption_key events
2026-11-20 11:37:20 +01:00
Johannes Marbach eabc6c0823 Merge branch 'main' into johannes/stable-rtc-device 2026-11-20 10:53:09 +01:00
renovate[bot] 7d6fbd336d Update ghcr.io/element-hq/element-web:develop Docker digest to dd8dbe3 (#4482)
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
2026-11-20 09:52:33 +00:00
Johannes Marbach f9fb566f41 Merge branch 'main' into johannes/stable-rtc-device 2026-11-20 09:21:20 +01:00
Robin ef1f69e085 Merge pull request #4342 from element-hq/valere/cleanup_sound_licence_listing
Sound listing clean-up
2026-11-19 14:42:58 -05:00
Santino Wagner 95a646b3bc Keep the tile buttons clear of the footer when it overlays the video
In a call view at most 600px high, and in a one-on-one call in a view
at most 600px wide, the footer is drawn over the video. The spotlight
tile's bottom-right buttons (full screen, expand, screen share volume)
stayed pinned to the tile's bottom edge, underneath the footer, so a
click on them landed on the footer instead.

Offset the buttons by --call-view-safe-area-inset-bottom, which the call
view already sets to the footer's height while the footer overlays the
tiles. The media foreground of a maximised tile uses the same inset. The
variable is unset in every other layout, so nothing moves there.

The rule is not limited to maximised tiles: with the layout switch on
"grid", a short window shows a spotlight tile that is not maximised but
still reaches the bottom edge.
2026-11-19 16:35:00 +01:00
Robin 86ad9bcb28 Merge pull request #4475 from element-hq/robin/clean-release-notes
Hide Docker and Actions updates from release notes
2026-11-19 09:42:41 -05:00
Johannes Marbach 7cd9ed8022 Merge pull request #4477 from element-hq/johannes/stable-rtc-member
Request capability to receive m.rtc.member events
2026-11-19 15:34:10 +01:00
Johannes Marbach 6cdcd5e83e Merge branch 'main' into johannes/stable-rtc-device 2026-11-19 09:16:01 +01:00
Robin df1156b385 Hide Docker and Actions updates from release notes
To make the release notes more scannable.
2026-11-18 14:06:18 -05:00
Johannes Marbach 1cdcb62791 Request capability to receive m.rtc.encryption_key events 2026-11-18 11:16:41 +01:00
Valere 25c4f14d8f Sound listing clean-up 2026-10-09 16:06:19 +02:00
16 changed files with 551 additions and 45 deletions
+2 -2
View File
@@ -19,10 +19,10 @@ services:
- ./backend/playwright_homeserver-othersite.yaml:/data/cfg/homeserver.yaml:Z
element-web:
# Pin to a SHA so that upstream cannot break our tests. Renovate handles regular updates.
image: ghcr.io/element-hq/element-web:develop@sha256:f85350f2b31a7521a800d9050e9f5c0676d04cfb60675242ccc0c6e25cad7d04
image: ghcr.io/element-hq/element-web:develop@sha256:2f9e5d993e20adbd062453fd1c437821d554bac1f22ed3177290b7911f667848
element-web-1:
# Pin to a SHA so that upstream cannot break our tests. Renovate handles regular updates.
image: ghcr.io/element-hq/element-web:develop@sha256:f85350f2b31a7521a800d9050e9f5c0676d04cfb60675242ccc0c6e25cad7d04
image: ghcr.io/element-hq/element-web:develop@sha256:2f9e5d993e20adbd062453fd1c437821d554bac1f22ed3177290b7911f667848
volumes:
# The other site opens the embedded package under test in place of the
# copy its image bundles (the first site opens the dev server's app.
+78
View File
@@ -0,0 +1,78 @@
/*
Copyright 2026 Element Creations Ltd.
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
Please see LICENSE in the repository root for full details.
*/
import { expect, test, type Page } from "@playwright/test";
import { SpaHelpers } from "./spa-helpers.ts";
test.use({
launchOptions: {
args: [
"--use-fake-ui-for-media-stream",
"--use-fake-device-for-media-stream=device-count=2",
"--mute-audio",
],
},
});
test.describe("the camera menu", () => {
test.skip(
({ browserName }) => browserName !== "chromium",
"Only Chromium offers a second fake camera",
);
test("moves the preview to the camera picked, and the call after it", async ({
page,
}) => {
await page.goto("/");
await SpaHelpers.createCall(page, "Camera user", "Camera switch");
await expectCamera(page, "fake_device_0");
await selectCamera(page, "fake_device_1");
await expectCamera(page, "fake_device_1");
await page.getByTestId("lobby_joinCall").click();
await expect(page.getByTestId("name_tag")).toContainText("Camera user");
await expectCamera(page, "fake_device_1");
await selectCamera(page, "fake_device_0");
await expectCamera(page, "fake_device_0");
// Turning the camera on again opens it anew
const camera = page.getByTestId("incall_videomute");
await camera.click();
await expect(camera).toHaveAttribute("aria-checked", "false");
await camera.click();
await expect(camera).toHaveAttribute("aria-checked", "true");
await expectCamera(page, "fake_device_0");
});
});
async function selectCamera(page: Page, name: string): Promise<void> {
await page.getByRole("button", { name: "Camera", exact: true }).click();
await page.getByRole("menuitemradio", { name }).click();
// Selecting doesn't close the menu, so dismiss it.
await page.keyboard.press("Escape");
await expect(page.getByRole("menu")).not.toBeVisible();
}
/** Every video on the page shows this camera, and there is one that does. */
async function expectCamera(page: Page, label: string): Promise<void> {
await expect
.poll(async () =>
page.evaluate(() => [
...new Set(
[...document.querySelectorAll("video")].flatMap((video) =>
video.srcObject instanceof MediaStream
? video.srcObject.getVideoTracks().map((track) => track.label)
: [],
),
),
]),
)
.toEqual([label]);
}
+36
View File
@@ -0,0 +1,36 @@
/*
Copyright 2026 Element Creations Ltd.
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
Please see LICENSE in the repository root for full details.
*/
import { expect, test } from "@playwright/test";
import { SpaHelpers } from "./spa-helpers.ts";
test("The full screen button can be clicked while the footer overlays the video", async ({
page,
}) => {
await page.goto("/");
await SpaHelpers.createCall(page, "John Doe", "ShortWindow", true);
await SpaHelpers.expectVideoTilesCount(page, 1);
const fullScreenButton = page.getByRole("button", { name: "maximise" });
const footer = page.getByTestId("footer-container");
// Short enough for the footer to be drawn over the video
await page.setViewportSize({ width: 1000, height: 500 });
await expect(fullScreenButton).toBeVisible();
await page.getByTestId("videoTile").first().hover();
await expect(footer).toHaveCSS("opacity", "1");
const buttonBox = (await fullScreenButton.boundingBox())!;
const footerBox = (await footer.boundingBox())!;
expect(buttonBox.y + buttonBox.height).toBeLessThanOrEqual(footerBox.y);
await fullScreenButton.click();
await expect
.poll(async () => page.evaluate(() => document.fullscreenElement !== null))
.toBe(true);
});
+95
View File
@@ -0,0 +1,95 @@
/*
Copyright 2026 Element Creations Ltd.
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
Please see LICENSE in the repository root for full details.
*/
import { expect, test, type Page } from "@playwright/test";
import { widgetTest } from "../fixtures/widget-user.ts";
import { TestHelpers } from "./test-helpers.ts";
widgetTest.use({ callType: "dm" });
// The bug from issue #4403, in a real call between two users in Element Web.
// 1. Brooks' browser is made slow: it lists its camera and microphone only
// after the call is on screen.
// 2. Brooks starts a video call in a DM. A DM call has no lobby.
// 3. Whistler picks up.
// 4. Brooks' camera button shows "on".
// 5. Whistler must see two videos: their own and the one brooks sends.
// Before the fix whistler saw only their own video.
//
// What it guards: the unit tests only check the mute button's own logic. This
// test checks the whole chain: button, call, SFU, and what the other person
// really sees. The bug depends on timing (camera listed before or after the
// call opens), so the normal DM call tests pass by luck most of the time.
// This test forces the bad timing every run, so a regression shows up always
// and not only sometimes.
widgetTest(
"Publishes a camera the browser lists only once the call is on screen",
async ({ asWidget, browserName }) => {
test.skip(
browserName === "firefox",
"The is test is not working on firefox CI environment. No mic/audio device inputs so cam/mic are disabled",
);
// Two Element Webs and a real call.
test.slow();
const { brooks, whistler } = asWidget;
await listDevicesOnlyInTheCall(brooks.page);
await TestHelpers.startCallInCurrentRoom(brooks.page, false);
await expect(whistler.page.getByText("Incoming video call")).toBeVisible();
await whistler.page
.getByRole("alert")
.getByRole("button", { name: "Join" })
.click();
const brooksFrame = brooks.page
.locator('iframe[title="Element Call"]')
.contentFrame();
await expect(
brooksFrame.getByRole("switch", { name: "Stop video", checked: true }),
).toBeVisible();
// Whistler's own camera and the one brooks sends
const whistlerFrame = whistler.page
.locator('iframe[title="Element Call"]')
.contentFrame();
await TestHelpers.expectVisibleVideoCount(whistlerFrame, 2);
await expect(whistlerFrame.getByText("Waiting for media...")).toHaveCount(
0,
);
},
);
/**
* Holds the device list back in the widget until the call view shows a tile,
* as a browser that is slow to answer does. Call before the widget loads.
*
* How: it replaces the browser's `enumerateDevices` with one that waits. It
* checks every 50ms whether a video tile is on the page, waits half a second
* more, and only then gives the real list. Element Web itself (the outer
* page) is left alone; only the call inside the iframe is slowed down.
*/
async function listDevicesOnlyInTheCall(page: Page): Promise<void> {
await page.addInitScript(() => {
if (window.parent === window) return;
const devices = navigator.mediaDevices;
const enumerate = devices.enumerateDevices.bind(devices);
const inTheCall = new Promise<void>((resolve) => {
const poll = setInterval(() => {
if (document.querySelector("[data-testid='videoTile']") === null)
return;
clearInterval(poll);
setTimeout(resolve, 500);
}, 50);
});
devices.enumerateDevices = async (): Promise<MediaDeviceInfo[]> => {
await inTheCall;
return enumerate();
};
});
}
+5 -3
View File
@@ -5,7 +5,7 @@
"schedule:monthly",
":enableVulnerabilityAlertsWithLabel(security)"
],
"addLabels": ["dependencies"],
"labels": ["dependencies"],
"minimumReleaseAge": "5 days",
"packageRules": [
{
@@ -16,7 +16,8 @@
{
"groupName": "GitHub Actions",
"matchDepTypes": ["action"],
"pinDigests": true
"pinDigests": true,
"labels": ["PR-Task"]
},
{
"description": "Disable Renovate for packages we want to monitor ourselves",
@@ -69,7 +70,8 @@
"matchUpdateTypes": ["digest"],
"schedule": ["* 0-3 * * *"],
"minimumReleaseAge": null,
"automerge": true
"automerge": true,
"labels": ["PR-Task"]
}
],
"semanticCommits": "disabled",
+53 -3
View File
@@ -24,7 +24,7 @@ describe("createLocalMedia", () => {
]);
expect(getUserMedia).toHaveBeenCalledExactlyOnceWith({
audio: { deviceId: "mic" },
audio: { deviceId: { exact: "mic" } },
video: { width: 640, height: 480, frameRate: undefined },
});
expect(tracks.map((t) => t.source)).toEqual(["microphone", "camera"]);
@@ -124,7 +124,7 @@ describe("createLocalMedia", () => {
await camera.setDevice("other");
expect(getUserMedia).toHaveBeenLastCalledWith({
video: { deviceId: "other" },
video: { deviceId: { exact: "other" } },
});
expect(first.stop).toHaveBeenCalled();
expect(processor.restart).toHaveBeenCalledOnce();
@@ -133,7 +133,53 @@ describe("createLocalMedia", () => {
expect(input).toBe(vi.mocked(processor.init).mock.calls[0][1]);
expect(tracksOn(element)).toEqual([processor.output]);
expect(media.takeTracks().get("camera")?.constraints).toEqual({
deviceId: "other",
deviceId: { exact: "other" },
});
});
it("opens the browser's choice where the device asked for is gone", async () => {
const getUserMedia = vi.mocked(fakeGetUserMedia());
getUserMedia.mockRejectedValueOnce(overconstrained());
const media = createLocalMedia(getUserMedia);
const tracks = await media.capture([
{ source: "microphone", deviceId: "unplugged" },
{ source: "camera", deviceId: "cam" },
]);
expect(getUserMedia).toHaveBeenLastCalledWith({ audio: {}, video: {} });
expect(tracks.map((t) => t.source)).toEqual(["microphone", "camera"]);
});
it("keeps the camera it has where another cannot be opened", async () => {
const getUserMedia = vi.mocked(fakeGetUserMedia());
const media = createLocalMedia(getUserMedia);
const [camera] = await media.capture([
{ source: "camera", deviceId: "cam" },
]);
const first = trackBehind(camera);
getUserMedia.mockRejectedValueOnce(overconstrained());
await expect(camera.setDevice("unplugged")).rejects.toThrow();
expect(first.stop).not.toHaveBeenCalled();
expect(media.takeTracks().get("camera")).toMatchObject({
track: first,
constraints: { deviceId: { exact: "cam" } },
});
});
it("lets go of the device it was opened on to face the other way", async () => {
const getUserMedia = fakeGetUserMedia({ facingMode: "user" });
const media = createLocalMedia(getUserMedia);
const [camera] = (await media.capture([
{ source: "camera", deviceId: "front" },
])) as [LocalVideoMediaTrack];
await camera.switchFacingMode();
expect(getUserMedia).toHaveBeenLastCalledWith({
video: { facingMode: "environment" },
});
});
@@ -227,6 +273,10 @@ function fakeGetUserMedia(videoSettings?: MediaTrackSettings): GetUserMedia {
});
}
function overconstrained(): Error {
return Object.assign(new Error("deviceId"), { name: "OverconstrainedError" });
}
function fakeProcessor(): VideoProcessor & { output: MediaStreamTrack } {
const output = fakeTrack("video");
return {
+83 -14
View File
@@ -78,11 +78,14 @@ export function createLocalMedia(
);
bySource.set(request.source, request);
}
const constraints: MediaStreamConstraints = {};
for (const request of bySource.values())
constraints[request.source === "microphone" ? "audio" : "video"] =
trackConstraints(request);
const stream = await getUserMedia(constraints);
const { stream, constraints } = await open(getUserMedia, {
microphone: bySource.has("microphone")
? trackConstraints(bySource.get("microphone")!)
: undefined,
camera: bySource.has("camera")
? trackConstraints(bySource.get("camera")!)
: undefined,
});
const captured: CapturedTrack[] = [];
for (const track of stream.getTracks()) {
const source: Source = track.kind === "audio" ? "microphone" : "camera";
@@ -91,7 +94,7 @@ export function createLocalMedia(
const captured_ = new CapturedTrack(
source,
track,
trackConstraints(request),
constraints[source]!,
getUserMedia,
);
capturedTracks.set(source, captured_);
@@ -139,9 +142,50 @@ export function createLocalMedia(
};
}
type SourceConstraints = Partial<Record<Source, MediaTrackConstraints>>;
/**
* Opens the devices asked for. Where one of them is gone, as a remembered
* choice that was unplugged, the browser picks instead.
*
* This is needed because we use `exact` device ids: an exact request for a
* device that no longer exists fails, where a preferred one would have opened
* another device. Without the retry here a stale choice would open nothing.
*/
async function open(
getUserMedia: GetUserMedia,
constraints: SourceConstraints,
): Promise<{ stream: MediaStream; constraints: SourceConstraints }> {
const streamOf = async (wanted: SourceConstraints): Promise<MediaStream> =>
getUserMedia({
...(wanted.microphone && { audio: wanted.microphone }),
...(wanted.camera && { video: wanted.camera }),
});
try {
return { stream: await streamOf(constraints), constraints };
} catch (e) {
if (!(e instanceof Error) || e.name !== "OverconstrainedError") throw e;
const anyDevice: SourceConstraints = {
...(constraints.microphone && {
microphone: { ...constraints.microphone, deviceId: undefined },
}),
...(constraints.camera && {
camera: { ...constraints.camera, deviceId: undefined },
}),
};
return { stream: await streamOf(anyDevice), constraints: anyDevice };
}
}
/** The constraints a request means to the browser. */
function trackConstraints(request: Request): MediaTrackConstraints {
const device = request.deviceId && { deviceId: request.deviceId };
// THE FIX for "cannot switch cameras in Chrome" (#4479), first capture.
// `exact` makes the browser open this device or fail. A plain
// `deviceId: "abc"` is only a wish, and Chromium ignores the wish and
// opens its default device.
const device = request.deviceId && {
deviceId: { exact: request.deviceId },
};
if (request.source === "microphone") return { ...device, ...request.capture };
const resolution = request.capture?.resolution;
return {
@@ -184,7 +228,12 @@ class CapturedTrack {
// The device actually in use, so that a backend asked for it again
// recognises it rather than restarting the track
const { deviceId } = track.getSettings();
const constraints = { ...this.constraints, ...(deviceId && { deviceId }) };
// `exact` here too: the call reopens the camera with these constraints
// after a mute, and must get the same device again, not the default one
const constraints = {
...this.constraints,
...(deviceId && { deviceId: { exact: deviceId } }),
};
this.finish();
return { track, constraints, muted: this.muted$.value, processor };
}
@@ -245,12 +294,28 @@ class CapturedTrack {
for (const element of this.elements) play(element, this.shown());
}
private async reacquire(constraints: MediaTrackConstraints): Promise<void> {
/**
* Replace the current with the one from the selector. On fail, keep current.
*
* The old `deviceId` and `facingMode` are removed before the new selector
* is applied. This is needed because we use `exact` device ids: if the old
* exact id stayed, asking for a new facing mode could not leave the deviceId.
* "flip camera" would do nothing.
*/
private async reacquire(
selector: Pick<MediaTrackConstraints, "deviceId" | "facingMode">,
): Promise<void> {
this.live();
this.constraints = { ...this.constraints, ...constraints };
const stream = await this.getUserMedia({
[this.track.kind]: this.constraints,
});
const constraints = {
...this.constraints,
// One selects the device at a time: a facing mode cannot move a track
// off a device it is pinned to
deviceId: undefined,
facingMode: undefined,
...selector,
};
const stream = await this.getUserMedia({ [this.track.kind]: constraints });
this.constraints = constraints;
this.track.stop();
this.track = stream.getTracks()[0];
this.track.enabled = !this.muted$.value;
@@ -288,7 +353,11 @@ class CapturedTrack {
},
setDevice: async (deviceId: string): Promise<void> => {
if (this.track.getSettings().deviceId === deviceId) return;
await this.reacquire({ deviceId });
// THE FIX for "cannot switch cameras in Chrome" (#4479), switching in
// the lobby. With a plain `{ deviceId }` Chromium reopened the same
// camera, so the preview only flashed. `exact` opens the one picked,
// or rejects and leaves the current camera running.
await this.reacquire({ deviceId: { exact: deviceId } });
},
};
if (this.source === "microphone")
+4 -1
View File
@@ -143,7 +143,10 @@ export interface LocalMediaTrack {
* from the request where the device could not be used.
*/
setEnabled(enabled: boolean): Promise<boolean>;
/** Captures from another device. Rejects for a screen share, which has none. */
/**
* Captures from another device. Rejects where that device cannot be opened,
* leaving the track on the one it had, and for a screen share, which has none.
*/
setDevice(deviceId: string): Promise<void>;
}
@@ -210,11 +210,7 @@ describe("createLivekitMediaTrack", () => {
await expect(track.setEnabled(false)).resolves.toBe(false);
expect(setEnabled).toHaveBeenCalledWith("microphone", false);
await track.setDevice("mic-2");
expect(switchActiveDevice).toHaveBeenCalledWith(
"audioinput",
"mic-2",
false,
);
expect(switchActiveDevice).toHaveBeenCalledWith("audioinput", "mic-2");
});
// LiveKit's media stream track is the processed one while a processor runs,
@@ -225,19 +221,23 @@ describe("createLivekitMediaTrack", () => {
])(
"leaves a processed camera alone unless its device changes: $deviceId",
async ({ deviceId, switches }) => {
let openDevice = "cam-1";
const camera = Object.assign(Object.create(LocalVideoTrack.prototype), {
source: Track.Source.Camera,
_mediaStreamTrack: {
readyState: "live",
label: "",
getSettings: () => ({ deviceId: "cam-1" }),
getSettings: () => ({ deviceId: openDevice }),
},
// What LiveKit shows as the track, with no device of its own
processor: {
processedTrack: { label: "", getSettings: () => ({}) },
},
}) as LocalVideoTrack;
const switchActiveDevice = vi.fn().mockResolvedValue(true);
const switchActiveDevice = vi.fn(async (_kind: string, id: string) => {
openDevice = id;
return Promise.resolve(true);
});
const { participant, publication, room } = fakes({
track: camera as unknown as FakeTrack,
});
@@ -253,11 +253,38 @@ describe("createLivekitMediaTrack", () => {
await track.setDevice(deviceId);
expect(switchActiveDevice.mock.calls).toEqual(
switches ? [["videoinput", deviceId, false]] : [],
switches ? [["videoinput", deviceId]] : [],
);
},
);
it("rejects where the camera did not move to the device asked for", async () => {
const camera = Object.assign(Object.create(LocalVideoTrack.prototype), {
source: Track.Source.Camera,
_mediaStreamTrack: {
readyState: "live",
label: "",
getSettings: () => ({ deviceId: "cam-1" }),
},
}) as LocalVideoTrack;
const { participant, publication, room } = fakes({
track: camera as unknown as FakeTrack,
});
const track = createLocalLivekitMediaTrack(
scope,
Object.assign(participant, {
isLocal: true,
}) as unknown as LocalParticipant,
publication as unknown as TrackPublication,
Object.assign(room, {
switchActiveDevice: vi.fn().mockResolvedValue(true),
}),
vi.fn(),
);
await expect(track.setDevice("cam-2")).rejects.toThrow("another device");
});
it("takes the facing mode of a processed camera from the camera", async () => {
const source = {
readyState: "live",
@@ -208,11 +208,27 @@ export function createLocalLivekitMediaTrack(
(await current.getDeviceId(false)) === deviceId
)
return;
// THE FIX for "cannot switch cameras in Chrome" (#4479), switching in
// the call. No third argument: LiveKit then asks for the device with
// `exact`. Passing `false` there made it a wish, which Chromium ignores
// by reopening its default device.
await room.switchActiveDevice(
base.kind === "audio" ? "audioinput" : "videoinput",
deviceId,
false,
);
// A check that the switch really happened, so that a failure is an
// error and not silence. Asked of the track again rather than taken
// from LiveKit's answer, which compares against the processed track
// too. A muted track is stopped and takes the device on turning on again
const now = publication.track;
const deviceNow =
now instanceof LocalTrack && !now.isMuted
? await now.getDeviceId(false)
: undefined;
if (deviceNow !== undefined && deviceNow !== deviceId)
throw new MatrixRTCError(
`The ${base.source} is on another device than the one asked for`,
);
},
};
if (base.kind === "audio") return { ...base, ...local };
+6 -2
View File
@@ -16,12 +16,16 @@ The following sound effects have been licensed from Pixabay, under https://pixab
The following sound effects have been originally created by Element.
- `blocked`
- `end_talk`
- `start_talk_local`
- `start_talk_remote`
- `join_call`
- `end_call`
- `left_call`
- `screen_share_started`
- `ringtone`
- `call_declined`
- `call_timeout`
- `reactions/rock`
- `reactions/wave`
- `reactions/baduntss`
- `reactions/deer`
+105
View File
@@ -169,6 +169,111 @@ describe("MuteState", () => {
expect(syncingValues).toContain(true);
expect(syncingValues.at(-1)).toBe(false);
});
// The bug from issue #4403: we join a call without a lobby, and the browser
// tells us about the camera only after the call has started.
// 1. Start with no camera, with the camera set to be on by default.
// 2. Set a handler, like the call does when it starts.
// 3. The camera shows up.
// The handler must be called with "on", so the call publishes the camera,
// and the button must show "on" only after the handler is done.
//
// What it guards: the button and the real camera must never disagree. In
// the bug the button jumped to "on" by itself and nobody told the call, so
// the other side saw "Waiting for media". If someone changes how the
// default is applied and forgets the handler again, this test fails.
test("asks the handler for the default of a device listed after it was set", async () => {
const available$ = new BehaviorSubject(new Map<string, DeviceLabel>());
const muteState = new MuteState(
testScope,
aDevice(available$),
true,
constant(false),
);
const handler = vi.fn(async (desired: boolean) => Promise.resolve(desired));
muteState.setHandler(handler);
expect(muteState.enabled$.value).toBe(false);
available$.next(aCamera);
// On only once the handler has acted on it
expect(muteState.enabled$.value).toBe(false);
await flushPromises();
expect(handler).toHaveBeenLastCalledWith(true);
expect(muteState.enabled$.value).toBe(true);
expect(muteState.syncing$.value).toBe(false);
});
// A camera that is unplugged and plugged back in during a call.
// 1. Start with a camera, on by default, and set a handler.
// 2. The camera goes away, then comes back.
// The handler is told "off" when the camera goes away and is not called
// again. The camera stays off: we must not turn on a camera that the user
// may have turned off before.
//
// What it guards: a privacy problem the fix for #4403 could cause. The fix
// sends the default "on" to the handler. If it did that every time a
// camera shows up, replugging a camera (or leaving earpiece mode) would
// start sending video without the user asking. This test fails if the
// default is ever applied a second time during a call.
test("leaves a device that comes back under a handler off", async () => {
const available$ = new BehaviorSubject(aCamera);
const muteState = new MuteState(
testScope,
aDevice(available$),
true,
constant(false),
);
expect(muteState.enabled$.value).toBe(true);
const handler = vi.fn(async (desired: boolean) => Promise.resolve(desired));
muteState.setHandler(handler);
available$.next(new Map());
available$.next(aCamera);
await flushPromises();
expect(handler.mock.calls).toEqual([[false]]);
expect(muteState.enabled$.value).toBe(false);
});
// The lobby case, which must keep working as before: no handler is set.
// 1. Start with no camera, with the camera set to be on by default.
// 2. The camera shows up.
// The button shows "on" right away, with no waiting.
//
// What it guards: the lobby and the join read the button's value at once
// to decide which devices to open. If the fix for #4403 made the default
// wait for a handler here too, the value would be "off" for a moment and
// the lobby would open no camera. This test fails if that happens.
test("assumes the default at once where no handler is set", () => {
const available$ = new BehaviorSubject(new Map<string, DeviceLabel>());
const muteState = new MuteState(
testScope,
aDevice(available$),
true,
constant(false),
);
available$.next(aCamera);
expect(muteState.enabled$.value).toBe(true);
});
// A device list with one camera in it.
const aCamera = new Map<string, DeviceLabel>([
["fbac11", { type: "name", name: "HD Camera" }],
]);
// A fake camera whose device list the test can change while it runs.
function aDevice(
available$: BehaviorSubject<Map<string, DeviceLabel>>,
): MediaDevice<DeviceLabel, SelectedDevice> {
return {
available$,
selected$: constant({ id: "fbac11" }),
select(): void {},
} as unknown as MediaDevice<DeviceLabel, SelectedDevice>;
}
});
describe("MuteStates", () => {
+26 -10
View File
@@ -53,6 +53,8 @@ export class MuteState<Label, Selected> {
this.handler$.next(defaultHandler);
}
private devicesConnectedBefore = false;
private readonly canControlDevices$ = combineLatest([
this.device.available$,
this.forceMute$,
@@ -86,15 +88,26 @@ export class MuteState<Label, Selected> {
};
}
// Assume the default value only once devices are actually connected
let enabled = this.enabledByDefault;
// defaultHander = no-op hanlder = "no actual device handler available"
const handlerAttached = this.handler$.value !== defaultHandler;
const deviceCameBackInCall =
handlerAttached && this.devicesConnectedBefore;
// Set the flag. A marker, that we reached this code before.
this.devicesConnectedBefore = true;
const initialWanted = deviceCameBackInCall
? false
: this.enabledByDefault;
// With a handler attached we start off and let the sync below actually call
// the handler, so the switch shows "on" only once the track is really there.
// Without one (lobby) enabled = initialWanted -> no call to handler.
let enabled = handlerAttached ? false : initialWanted;
const set$ = new Subject<boolean>();
const toggle$ = new Subject<void>();
const syncing$ = new BehaviorSubject(false);
const desired$ = merge(set$, toggle$.pipe(map(() => !enabled)));
const enabled$ = new Observable<boolean>((subscriber) => {
subscriber.next(enabled);
let latestDesired = this.enabledByDefault;
let latestDesired = initialWanted;
const sync = async (): Promise<void> => {
if (enabled === latestDesired) {
@@ -120,16 +133,19 @@ export class MuteState<Label, Selected> {
}
};
const startSync = (): void => {
syncing$.next(true);
sync().catch((err) => {
// TODO: better error handling
logger.error("MuteState: handler error", err);
});
};
const s = desired$.subscribe((desired) => {
latestDesired = desired;
if (syncing$.value === false) {
syncing$.next(true);
sync().catch((err) => {
// TODO: better error handling
logger.error("MuteState: handler error", err);
});
}
if (syncing$.value === false) startSync();
});
if (enabled !== latestDesired) startSync();
return (): void => {
s.unsubscribe();
syncing$.complete();
+4 -1
View File
@@ -111,7 +111,10 @@ Please see LICENSE in the repository root for full details.
display: flex;
gap: var(--cpd-space-2x);
position: absolute;
inset-block-end: var(--cpd-space-1x);
/* Ensure that the buttons lie within the safe area */
inset-block-end: calc(
var(--call-view-safe-area-inset-bottom, 0px) + var(--cpd-space-1x)
);
inset-inline-end: var(--cpd-space-1x);
z-index: 1;
}
+1
View File
@@ -101,6 +101,7 @@ describe("widget", () => {
EventType.CallSDPStreamMetadataChangedPrefix,
EventType.CallReplaces,
EventType.CallEncryptionKeysPrefix,
"m.rtc.encryption_key",
];
expect(createRoomWidgetClientSpy.mock.calls[0][1]).toStrictEqual({
+1
View File
@@ -163,6 +163,7 @@ export const initializeWidget = (
EventType.CallSDPStreamMetadataChangedPrefix,
EventType.CallReplaces,
EventType.CallEncryptionKeysPrefix,
"m.rtc.encryption_key",
];
const client = createRoomWidgetClient(