fix(app): stop capture before closing and break push token recursion

Author: AnkushMalaker

app/scripts/test-phone-audio-diagnostics.cjs

@@ -28,6 +28,7 @@ const writes = [];
 const socketSourcePath = path.join(__dirname, '../src/protocol/audioV2Socket.ts');
 const serverControls = {
   hello: { event: { case: 'hello', value: {} } },
+  captureStopped: { event: { case: 'captureStopped', value: {} } },
   captureStarted: {
     event: {
       case: 'captureStarted',
@@ -127,6 +128,15 @@ async function declaredUplinkDuration(frameDurationMs) {
   });
   transport.receive('captureStarted');
   await starting;
+  let stopped = false;
+  const stopping = socket.stopCapture().then(() => { stopped = true; });
+  await Promise.resolve();
+  assert.equal(stopped, false, 'stop must await the server acknowledgement');
+  assert.equal(transport.sent.at(-1).event.case, 'stopCapture');
+  transport.receive('captureStopped');
+  await stopping;
+  assert.equal(socket.activeBinding, null, 'acknowledged stop must release the capture');
+  socket.close();
   return transport.sent.map(control => (
     control.event.value.audioSpec ?? control.event.value.supportedUplink?.[0]
   )).filter(Boolean).map(spec => spec.frameDuration.nanos);

app/scripts/test-phone-audio-streaming.cjs

@@ -38,6 +38,7 @@ const socketFrameDurations = [];
 const diagnostics = [];
 let backendStops = 0;
 let socketCloses = 0;
+let duringBackendStop = () => {};
 
 class MockAudioV2Socket {
   constructor(options) {
@@ -66,6 +67,7 @@ class MockAudioV2Socket {
 
   async stopCapture() {
     backendStops += 1;
+    await duringBackendStop();
     this.activeBinding = null;
   }
 
@@ -165,7 +167,19 @@ const { useAudioStreamer } = loadTypeScript(sourcePath, {
   assert.deepEqual(Array.from(sentPackets[0].opus), [1, 2, 3]);
   assert.deepEqual(diagnostics, [['sent', 3], ['accepted', 0]]);
 
+  duringBackendStop = async () => {
+    const before = sentPackets.length;
+    streamer.sendFrame('phone', {
+      captureEpoch: 7,
+      capturedAtMs: 1_780_000_000_040,
+      monotonicTimestampMs: now + 40,
+      opus: new Uint8Array([4]),
+    });
+    assert.equal(sentPackets.length, before, 'queued native callbacks must not send after stop');
+    assert.equal(nativeStops, 1, 'microphone must stop before waiting for the backend');
+  };
   await streamer.stopStreaming();
+  duringBackendStop = () => {};
   assert.equal(backendStops, 1, 'the capture has one stop owner');
   assert.equal(nativeStops, 1, 'stopping the stream also stops the native phone session');
   assert.equal(socketCloses, 1);
@@ -180,6 +194,28 @@ const { useAudioStreamer } = loadTypeScript(sourcePath, {
   assert.equal(beginCaptureCalls[1].deliveryClass, DeliveryClass.LIVE);
   await wearableStreamer.stopStreaming();
 
+  for (const failureAt of ['native', 'backend']) {
+    const failingStreamer = useAudioStreamer();
+    const expected = new Error(`${failureAt} stop failed`);
+    await failingStreamer.startStreaming('wss://chronicle.invalid/ws/audio', {
+      kind: 'phone',
+      ...phoneVoice,
+      stopCapture: async () => {
+        if (failureAt === 'native') throw expected;
+      },
+    });
+    const closesBefore = socketCloses;
+    duringBackendStop = async () => { throw expected; };
+    await assert.rejects(failingStreamer.stopStreaming(), error => error === expected);
+    assert.equal(socketCloses, closesBefore + 1, 'stop failure must still close the transport');
+    const packetsBefore = sentPackets.length;
+    failingStreamer.sendFrame('phone', {
+      captureEpoch: 7, capturedAtMs: 1_780_000_000_060,
+      monotonicTimestampMs: now + 60, opus: new Uint8Array([5]),
+    });
+    assert.equal(sentPackets.length, packetsBefore, 'failed stop must leave capture inactive');
+  }
+
   console.log('phone audio streaming tests passed');
 })().catch(error => {
   console.error(error);

app/scripts/test-push-notifications.cjs

@@ -31,13 +31,19 @@ const requests = [];
 const opened = [];
 const alerts = [];
 let pushTokenListener = null;
+let nativeTokenFetches = 0;
 const notifications = {
   PermissionStatus: { DENIED: 'denied' },
   AndroidImportance: { HIGH: 4, DEFAULT: 3 },
   getPermissionsAsync: async () => permission,
   requestPermissionsAsync: async () => permission,
-  getExpoPushTokenAsync: async ({ projectId }) => {
+  getExpoPushTokenAsync: async ({ projectId, devicePushToken }) => {
     assert.equal(projectId, 'project-one');
+    // Expo requests a native token if none is supplied; iOS emits the listener
+    // again when that request completes. Bound the buggy loop in this fixture.
+    if (!devicePushToken && pushTokenListener && ++nativeTokenFetches < 5) {
+      pushTokenListener({ type: 'ios', data: 'rotated' });
+    }
     return { data: 'ExpoPushToken[abcdefghijklmnopqrstuvwxyz]' };
   },
   setNotificationHandler() {},
@@ -100,8 +106,9 @@ const push = loadTypeScript(sourcePath, {
   await push.refreshPushRegistration('wss://chronicle/ws/audio');
   assert.equal(requests.length, 2, 'authenticated launch refreshes the registration');
   const stopTokenListener = push.listenForPushTokenChanges('wss://chronicle/ws/audio');
-  pushTokenListener({ type: 'expo', data: 'rotated' });
+  pushTokenListener({ type: 'ios', data: 'rotated' });
   await new Promise(resolve => setImmediate(resolve));
+  assert.equal(nativeTokenFetches, 0, 'rotation must use the supplied native token without requesting another');
   assert.equal(requests.length, 3, 'native token changes refresh the Expo registration');
   stopTokenListener();
 

app/src/hooks/useAudioStreamer.ts

@@ -142,16 +142,16 @@ export const useAudioStreamer = (): UseAudioStreamer => {
     heartbeatRef.current = null;
     const socket = socketRef.current;
     try {
+      if (sourceRef.current?.kind === 'phone') {
+        await sourceRef.current.stopCapture();
+      }
       await socket?.stopCapture();
     } finally {
       socket?.close();
       socketRef.current = null;
       playbackSubscriptionRef.current?.remove();
       playbackSubscriptionRef.current = null;
       playbackRef.current = null;
-      if (sourceRef.current?.kind === 'phone') {
-        await sourceRef.current.stopCapture();
-      }
       sourceRef.current = null;
       setIsStreaming(false);
       setIsConnecting(false);
@@ -297,7 +297,7 @@ export const useAudioStreamer = (): UseAudioStreamer => {
     source: AudioStreamSource['kind'],
     frame: CapturedOpusFrame,
   ) => {
-    if (!frame.opus.length) return;
+    if (stoppedRef.current || !frame.opus.length) return;
     const activeSource = sourceRef.current;
     const socket = socketRef.current;
     if (!socket?.activeBinding || activeSource?.kind !== source) return;

app/src/services/pushNotifications.ts

@@ -45,9 +45,12 @@ export const configureNotificationPresentation = async (): Promise<void> => {
   }
 };
 
-const registerToken = async (backendUrl: string): Promise<void> => {
+const registerToken = async (
+  backendUrl: string,
+  devicePushToken?: Notifications.DevicePushToken,
+): Promise<void> => {
   if (!projectId) throw new Error('This build has no EAS project ID.');
-  const token = await Notifications.getExpoPushTokenAsync({ projectId });
+  const token = await Notifications.getExpoPushTokenAsync({ projectId, devicePushToken });
   const installationId = await getOrCreateInstallationId();
   const response = await fetchAuthed(
     `${deriveBaseUrl(backendUrl)}/api/notifications/devices/${encodeURIComponent(installationId)}`,
@@ -123,8 +126,8 @@ export const startNotificationTapHandling = async (): Promise<() => void> => {
 /** Native-token rotation means the Expo token must be fetched and registered again. */
 export const listenForPushTokenChanges = (backendUrl: string): (() => void) => {
   if (Platform.OS === 'web') return () => {};
-  const subscription = Notifications.addPushTokenListener(() => {
-    void refreshPushRegistration(backendUrl).catch(error => {
+  const subscription = Notifications.addPushTokenListener(devicePushToken => {
+    void registerToken(backendUrl, devicePushToken).catch(error => {
       console.warn('[Notifications] token refresh failed:', error);
     });
   });