Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

fix(reading): isolate audio cleanup across delayed playback and unmount

Bingxi Zhao (Frank)8b51caf05543
diff --git a/web/components/reading/use-read-aloud-speech.ts b/web/components/reading/use-read-aloud-speech.ts
index 2a17761bd..881294410 100644
--- a/web/components/reading/use-read-aloud-speech.ts
+++ b/web/components/reading/use-read-aloud-speech.ts
@@ -4,22 +4,24 @@ import { useCallback, useEffect, useRef, useState } from "react";
import { readReadingAloudAudio } from "@/lib/reading-api";
-/**
- * Play server speech for a verified reading unit, with browser speech as the
- * offline/no-provider fallback. A token keeps late audio responses from
- * starting after the reader has navigated away or pressed stop.
- */
+type Playback = { audio: HTMLAudioElement; url: string; disposed: boolean };
+
+/** Play verified server speech, falling back to browser speech when unavailable. */
export function useReadAloudSpeech() {
const [speaking, setSpeaking] = useState(false);
const tokenRef = useRef(0);
- const audioRef = useRef<HTMLAudioElement | null>(null);
- const audioUrlRef = useRef<string | null>(null);
+ const playbackRef = useRef<Playback | null>(null);
- const disposeAudio = useCallback(() => {
- audioRef.current?.pause();
- if (audioUrlRef.current) URL.revokeObjectURL(audioUrlRef.current);
- audioRef.current = null;
- audioUrlRef.current = null;
+ const disposeAudio = useCallback((playback = playbackRef.current) => {
+ if (!playback) return;
+ if (!playback.disposed) {
+ playback.disposed = true;
+ playback.audio.onended = null;
+ playback.audio.onerror = null;
+ playback.audio.pause();
+ URL.revokeObjectURL(playback.url);
+ }
+ if (playbackRef.current === playback) playbackRef.current = null;
}, []);
const stop = useCallback(() => {
@@ -29,15 +31,14 @@ export function useReadAloudSpeech() {
setSpeaking(false);
}, [disposeAudio]);
- useEffect(() => disposeAudio, [disposeAudio]);
+ useEffect(() => () => {
+ tokenRef.current += 1;
+ disposeAudio();
+ window.speechSynthesis?.cancel();
+ }, [disposeAudio]);
const speak = useCallback(
- async ({
- materialId,
- locator,
- locale,
- fallbackText,
- }: {
+ async ({ materialId, locator, locale, fallbackText }: {
materialId: string;
locator: number;
locale: string;
@@ -46,33 +47,30 @@ export function useReadAloudSpeech() {
const token = ++tokenRef.current;
disposeAudio();
window.speechSynthesis?.cancel();
+ setSpeaking(false);
+ let playback: Playback | null = null;
try {
const blob = await readReadingAloudAudio(materialId, { locator });
if (tokenRef.current !== token || !blob.size) return false;
const url = URL.createObjectURL(blob);
const audio = new Audio(url);
- audioUrlRef.current = url;
- audioRef.current = audio;
- audio.onended = () => {
- if (tokenRef.current === token) {
- disposeAudio();
- setSpeaking(false);
- }
- };
- audio.onerror = () => {
- if (tokenRef.current === token) {
- disposeAudio();
- setSpeaking(false);
- }
+ playback = { audio, url, disposed: false };
+ playbackRef.current = playback;
+ const finished = () => {
+ disposeAudio(playback);
+ if (tokenRef.current === token) setSpeaking(false);
};
+ audio.onended = finished;
+ audio.onerror = finished;
await audio.play();
if (tokenRef.current !== token) {
- disposeAudio();
+ disposeAudio(playback);
return true;
}
- setSpeaking(true);
+ if (!playback.disposed) setSpeaking(true);
return true;
} catch {
+ disposeAudio(playback);
if (tokenRef.current !== token) return true;
}
diff --git a/web/tests/reading-read-aloud-speech.spec.ts b/web/tests/reading-read-aloud-speech.spec.ts
index 8d2d7b570..6783c6636 100644
--- a/web/tests/reading-read-aloud-speech.spec.ts
+++ b/web/tests/reading-read-aloud-speech.spec.ts
@@ -13,12 +13,12 @@ const audioInstances: {
play: ReturnType<typeof vi.fn>;
}[] = [];
-function installAudio() {
+function installAudio(play = () => Promise.resolve()) {
class FakeAudio {
onended: (() => void) | null = null;
onerror: (() => void) | null = null;
pause = vi.fn();
- play = vi.fn().mockResolvedValue(undefined);
+ play = vi.fn(play);
constructor() {
audioInstances.push(this);
@@ -151,3 +151,45 @@ it("stops server audio and releases its object URL", async () => {
expect(revokeObjectURL).toHaveBeenCalledWith("blob:reading-audio");
expect(result.current.speaking).toBe(false);
});
+
+
+it.each(["resolve", "reject"])("keeps newer audio playing when an older play promise later %ss", async (outcome) => {
+ let resolve!: () => void;
+ let reject!: (error: Error) => void;
+ const pending = new Promise<void>((yes, no) => { resolve = yes; reject = no; });
+ let plays = 0;
+ installAudio(() => ++plays === 1 ? pending : Promise.resolve());
+ const { createObjectURL, revokeObjectURL } = installObjectUrls();
+ createObjectURL.mockReturnValueOnce("blob:first").mockReturnValueOnce("blob:second");
+ vi.mocked(readReadingAloudAudio).mockResolvedValue({ size: 5 } as Blob);
+ const speech = installBrowserSpeech();
+ const { result } = renderHook(() => useReadAloudSpeech());
+ const request = { materialId: "material-1", locator: 1, locale: "en", fallbackText: "fallback" };
+ let first!: Promise<boolean>;
+ await act(async () => { first = result.current.speak(request); });
+ await act(async () => { await result.current.speak({ ...request, locator: 2 }); });
+ expect(result.current.speaking).toBe(true);
+ await act(async () => {
+ if (outcome === "resolve") resolve(); else reject(new Error("late playback failure"));
+ await first;
+ });
+ expect(audioInstances[1].pause).not.toHaveBeenCalled();
+ expect(revokeObjectURL).not.toHaveBeenCalledWith("blob:second");
+ expect(revokeObjectURL.mock.calls.filter(([url]) => url === "blob:first")).toHaveLength(1);
+ expect(speech.speak).not.toHaveBeenCalled();
+ expect(result.current.speaking).toBe(true);
+});
+
+it("does not start a late server response after unmount", async () => {
+ installAudio();
+ const { createObjectURL } = installObjectUrls();
+ let resolve!: (blob: Blob) => void;
+ vi.mocked(readReadingAloudAudio).mockReturnValueOnce(new Promise<Blob>((yes) => { resolve = yes; }));
+ const { result, unmount } = renderHook(() => useReadAloudSpeech());
+ let pending!: Promise<boolean>;
+ await act(async () => { pending = result.current.speak({ materialId: "material-1", locator: 1, locale: "en", fallbackText: "fallback" }); });
+ unmount();
+ await act(async () => { resolve({ size: 5 } as Blob); await pending; });
+ expect(createObjectURL).not.toHaveBeenCalled();
+ expect(audioInstances).toHaveLength(0);
+});