Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(web): release capture when recorder setup loses its source

Aditya Garud88d3ea5b1727
diff --git a/apps/web/__tests__/unit/comment-recorder-lifecycle.test.ts b/apps/web/__tests__/unit/comment-recorder-lifecycle.test.ts
new file mode 100644
index 000000000..e043cbcd3
--- /dev/null
+++ b/apps/web/__tests__/unit/comment-recorder-lifecycle.test.ts
@@ -0,0 +1,180 @@
+// @vitest-environment jsdom
+
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+ display: vi.fn(),
+ mic: vi.fn(),
+ mixer: vi.fn(),
+}));
+
+vi.mock("@cap/recorder-core/capture-streams", () => ({
+ acquireCameraStream: vi.fn(),
+ acquireCameraWithMicStream: vi.fn(),
+ acquireDisplayStream: mocks.display,
+ acquireMicStream: mocks.mic,
+ createAudioMixer: mocks.mixer,
+ getCaptureErrorMessage: (error: Error) => error.message,
+}));
+
+import { useCommentRecorder } from "@/app/s/[videoId]/_components/timeline/recording/useCommentRecorder";
+
+class Track extends EventTarget {
+ kind: "audio" | "video";
+ readyState: MediaStreamTrackState = "live";
+ stop = vi.fn(() => {
+ this.readyState = "ended";
+ });
+
+ constructor(kind: "audio" | "video") {
+ super();
+ this.kind = kind;
+ }
+
+ end() {
+ this.readyState = "ended";
+ this.dispatchEvent(new Event("ended"));
+ }
+
+ getSettings() {
+ return {};
+ }
+}
+
+class Stream {
+ constructor(private readonly tracks: Track[]) {}
+
+ getTracks() {
+ return this.tracks;
+ }
+
+ getVideoTracks() {
+ return this.tracks.filter((track) => track.kind === "video");
+ }
+
+ getAudioTracks() {
+ return this.tracks.filter((track) => track.kind === "audio");
+ }
+}
+
+class Recorder {
+ static isTypeSupported = () => true;
+ static startError: Error | null = null;
+
+ state: RecordingState = "inactive";
+ ondataavailable: ((event: BlobEvent) => void) | null = null;
+ onstop: ((event: Event) => void) | null = null;
+ onerror: ((event: Event) => void) | null = null;
+ mimeType = "video/webm";
+
+ constructor(private readonly stream: Stream) {}
+
+ start() {
+ if (Recorder.startError) throw Recorder.startError;
+ if (this.stream.getVideoTracks()[0]?.readyState === "ended") {
+ throw new DOMException("The video track ended", "InvalidStateError");
+ }
+ this.state = "recording";
+ }
+
+ stop() {
+ this.state = "inactive";
+ }
+}
+
+const deferred = <T>() => {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((done) => {
+ resolve = done;
+ });
+ return { promise, resolve };
+};
+
+describe("comment recorder lifecycle", () => {
+ let root: Root;
+ let container: HTMLDivElement;
+ let recorder: ReturnType<typeof useCommentRecorder>;
+
+ beforeEach(async () => {
+ vi.clearAllMocks();
+ Recorder.startError = null;
+ vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+ vi.stubGlobal("MediaStream", Stream);
+ vi.stubGlobal("MediaRecorder", Recorder);
+ container = document.createElement("div");
+ document.body.append(container);
+ root = createRoot(container);
+ function Harness() {
+ recorder = useCommentRecorder({
+ onFinish: vi.fn(),
+ selectedCameraId: null,
+ selectedMicId: "mic",
+ });
+ return null;
+ }
+ await act(async () => root.render(createElement(Harness)));
+ });
+
+ afterEach(async () => {
+ await act(async () => root.unmount());
+ container.remove();
+ vi.unstubAllGlobals();
+ });
+
+ it("releases capture when screen sharing ends during microphone setup", async () => {
+ const videoTrack = new Track("video");
+ const micTrack = new Track("audio");
+ const mixedTrack = new Track("audio");
+ const displayStream = new Stream([videoTrack]);
+ const micStream = new Stream([micTrack]);
+ const closeMixer = vi.fn(async () => {});
+ const pendingMic = deferred<Stream>();
+ mocks.display.mockResolvedValue(displayStream);
+ mocks.mic.mockReturnValue(pendingMic.promise);
+ mocks.mixer.mockResolvedValue({
+ context: {},
+ stream: new Stream([mixedTrack]),
+ setMicStream: vi.fn(),
+ close: closeMixer,
+ });
+
+ let starting!: Promise<void>;
+ await act(async () => {
+ starting = recorder.startScreen();
+ await Promise.resolve();
+ });
+ expect(recorder.phase).toBe("requesting");
+
+ videoTrack.end();
+ await act(async () => {
+ pendingMic.resolve(micStream);
+ await starting;
+ });
+
+ expect(recorder.phase).toBe("idle");
+ expect(videoTrack.stop).toHaveBeenCalled();
+ expect(micTrack.stop).toHaveBeenCalled();
+ expect(mixedTrack.stop).toHaveBeenCalled();
+ expect(closeMixer).toHaveBeenCalled();
+ });
+
+ it("releases capture when MediaRecorder rejects a live source", async () => {
+ const videoTrack = new Track("video");
+ mocks.display.mockResolvedValue(new Stream([videoTrack]));
+ mocks.mic.mockRejectedValue(new Error("No microphone"));
+ Recorder.startError = new DOMException(
+ "The recorder could not start",
+ "InvalidStateError",
+ );
+
+ await act(async () => recorder.startScreen());
+
+ expect(recorder.phase).toBe("idle");
+ expect(recorder.error).toBe(
+ "Recording couldn't start. Please choose the source again.",
+ );
+ expect(videoTrack.stop).toHaveBeenCalled();
+ });
+});
diff --git a/apps/web/app/s/[videoId]/_components/timeline/recording/useCommentRecorder.ts b/apps/web/app/s/[videoId]/_components/timeline/recording/useCommentRecorder.ts
index defaac2df..a22e2fb94 100644
--- a/apps/web/app/s/[videoId]/_components/timeline/recording/useCommentRecorder.ts
+++ b/apps/web/app/s/[videoId]/_components/timeline/recording/useCommentRecorder.ts
@@ -236,6 +236,13 @@ export function useCommentRecorder(options: {
const beginRecording = useCallback(
(stream: MediaStream) => {
+ const videoTrack = stream.getVideoTracks()[0];
+ if (!videoTrack || videoTrack.readyState === "ended") {
+ failRecording(
+ "The recording source ended before recording could start.",
+ );
+ return;
+ }
const hasAudio = stream.getAudioTracks().length > 0;
const pipeline = selectCommentVideoPipeline(hasAudio);
if (!pipeline) {
@@ -265,7 +272,7 @@ export function useCommentRecorder(options: {
// The browser's own "Stop sharing" bar ends the video track; treat it
// as a normal stop.
- stream.getVideoTracks()[0]?.addEventListener(
+ videoTrack.addEventListener(
"ended",
() => {
void stopRef.current?.();
@@ -273,7 +280,14 @@ export function useCommentRecorder(options: {
{ once: true },
);
- recorder.start(200);
+ try {
+ recorder.start(200);
+ } catch {
+ failRecording(
+ "Recording couldn't start. Please choose the source again.",
+ );
+ return;
+ }
startTimer();
setLiveMicSwitchable(mixerRef.current !== null);
updatePhase("recording");