@stream-io/video-client 1.61.0 → 1.61.2

package/src/ringing/__tests__/reconcileRingState.test.ts

@@ -202,6 +202,39 @@ describe('reconcileRingState', () => {
         message: 'ring: call ended',
       });
     });
+
+    describe('as the callee', () => {
+      const ended = { reason: 'ended', message: 'ring: call ended' };
+
+      it('leaves when the session has ended', async () => {
+        const call = ringingCall({ currentUserId: 'm2', createdById: 'm1' });
+        setSession(call, { ended_at: timestamp() });
+
+        expect(await reconcile(call)).toBe(true);
+        expect(call.leave).toHaveBeenCalledWith(ended);
+      });
+
+      it('leaves when the call itself has ended', async () => {
+        const call = ringingCall({ currentUserId: 'm2', createdById: 'm1' });
+        setSession(call, {});
+        call.state.setEndedAt(new Date());
+
+        expect(await reconcile(call)).toBe(true);
+        expect(call.leave).toHaveBeenCalledWith(ended);
+      });
+
+      it('leaves once with the ended message when the creator also rejected', async () => {
+        const call = ringingCall({ currentUserId: 'm2', createdById: 'm1' });
+        setSession(call, {
+          ended_at: timestamp(),
+          rejected_by: { m1: timestamp() },
+        });
+
+        expect(await reconcile(call)).toBe(true);
+        expect(call.leave).toHaveBeenCalledTimes(1);
+        expect(call.leave).toHaveBeenCalledWith(ended);
+      });
+    });
   });
 
   it('is terminal once the call is no longer ringing', async () => {

package/src/ringing/reconcileRingState.ts

@@ -6,15 +6,16 @@ import type { CallLeaveOptions } from '../types';
 /**
  * Decides what a ringing call should do next, based on the current call state.
  *
- * The `call.accepted`, `call.rejected` and `call.missed` handlers and the ring
- * state poller both run this. They differ only in how the state got there: the
- * handlers rely on `CallState.updateFromEvent`, which runs before them, and the
- * poller applies the polled ring state itself.
+ * The `call.accepted` and `call.rejected` handlers, the ring state poller and
+ * the rewatch after a WS reconnect all run this. They differ only in how the
+ * state got there: the handlers rely on `CallState.updateFromEvent`, which runs
+ * before them, while the poller applies the polled ring state itself and the
+ * rewatch applies the queried call state.
  *
  * @param call the call to reconcile.
- * @param joinSource which of the two triggered this run, reported on the
- * caller's join: `ring-ws` for the event handlers, `ring-poll-api` for the
- * poller.
+ * @param joinSource what triggered this run, reported on the caller's join:
+ * `ring-ws` for the event handlers, `ring-poll-api` for the poller and the
+ * rewatch (both come from an API response).
  * @returns whether the ring reached a terminal state. A failed join is not
  * terminal: the caller should keep trying while the ring is open.
  */
@@ -79,10 +80,17 @@ const reconcileAsCaller = async (
 };
 
 // the current user's own accept or reject, on this or another device, is
-// handled by `resolveOwnRingOutcome`, and `call.ended` by `watchCallEnded`.
+// handled by `resolveOwnRingOutcome`, and a live `call.ended` by
+// `watchCallEnded`. An end missed while offline is handled here.
 const reconcileAsCallee = async (call: Call): Promise<boolean> => {
-  const createdById = call.state.createdBy?.id;
-  const rejectedBy = call.state.session?.rejected_by ?? {};
+  const { session, endedAt, createdBy } = call.state;
+  if (endedAt || session?.ended_at) {
+    call.logger.info('ring: the call has ended, leaving');
+    return leave(call, { reason: 'ended', message: 'ring: call ended' });
+  }
+
+  const createdById = createdBy?.id;
+  const rejectedBy = session?.rejected_by ?? {};
   if (createdById && rejectedBy[createdById]) {
     call.logger.info('ring: the caller cancelled, leaving');
     return leave(call, {

package/src/rtc/BasePeerConnection.ts

@@ -344,9 +344,14 @@ export abstract class BasePeerConnection {
 
     // we can't recover from a failed connection state (contrary to ICE)
     if (state === 'failed') {
+      const reason = this.iceHasEverConnected
+        ? ReconnectReason.CONNECTION_FAILED
+        : ReconnectReason.ICE_NEVER_CONNECTED;
+      clearTimeout(this.preConnectStuckTimeout);
+      this.preConnectStuckTimeout = undefined;
       this.onReconnectionNeeded?.(
         WebsocketReconnectStrategy.REJOIN,
-        ReconnectReason.CONNECTION_FAILED,
+        reason,
         this.peerType,
       );
       return;

package/src/rtc/__tests__/Publisher.test.ts

@@ -931,6 +931,56 @@ describe('Publisher', () => {
       );
     });
 
+    it.each(['checking', 'failed'] as const)(
+      `connection-state 'failed' before ICE connects emits ICE_NEVER_CONNECTED when ICE is '%s'`,
+      async (iceState) => {
+        vi.spyOn(publisher, 'restartIce').mockResolvedValue();
+        publisher['onReconnectionNeeded'] = vi.fn();
+        // @ts-expect-error readonly field
+        publisher['pc'].iceConnectionState = iceState;
+        // @ts-expect-error readonly field
+        publisher['pc'].connectionState = 'failed';
+
+        // No ICE state-change event precedes the aggregate failure.
+        await publisher['onConnectionStateChange']();
+
+        expect(publisher.restartIce).not.toHaveBeenCalled();
+        expect(
+          publisher['onReconnectionNeeded'],
+        ).toHaveBeenCalledExactlyOnceWith(
+          WebsocketReconnectStrategy.REJOIN,
+          ReconnectReason.ICE_NEVER_CONNECTED,
+          PeerType.PUBLISHER_UNSPECIFIED,
+        );
+      },
+    );
+
+    it(`connection-state 'failed' cancels the pre-connect watchdog`, async () => {
+      vi.useFakeTimers();
+      publisher['onReconnectionNeeded'] = vi.fn();
+      const watchdogMs = publisher['iceRestartDelay'] * 2;
+
+      // @ts-expect-error readonly field
+      publisher['pc'].iceConnectionState = 'disconnected';
+      publisher['onIceConnectionStateChange']();
+      expect(publisher['preConnectStuckTimeout']).toBeDefined();
+      expect(publisher['onReconnectionNeeded']).not.toHaveBeenCalled();
+
+      // Keep ICE disconnected so an uncanceled watchdog would reconnect again.
+      // @ts-expect-error readonly field
+      publisher['pc'].connectionState = 'failed';
+      await publisher['onConnectionStateChange']();
+
+      expect(publisher['preConnectStuckTimeout']).toBeUndefined();
+      expect(publisher['onReconnectionNeeded']).toHaveBeenCalledExactlyOnceWith(
+        WebsocketReconnectStrategy.REJOIN,
+        ReconnectReason.ICE_NEVER_CONNECTED,
+        PeerType.PUBLISHER_UNSPECIFIED,
+      );
+      await vi.advanceTimersByTimeAsync(watchdogMs + 100);
+      expect(publisher['onReconnectionNeeded']).toHaveBeenCalledTimes(1);
+    });
+
     it(`connection-state 'failed' (distinct from ICE state) still fires REJOIN even after ICE was connected`, () => {
       // mark ICE as connected first
       // @ts-expect-error private api

package/src/stats/SfuStatsReporter.ts

@@ -1,20 +1,16 @@
-import { combineLatest } from 'rxjs';
 import { StreamSfuClient } from '../StreamSfuClient';
-import { OwnCapability, StatsOptions } from '../gen/coordinator';
+import { StatsOptions } from '../gen/coordinator';
 import { Publisher, Subscriber } from '../rtc';
-import { ComputedStats, PendingDelta, Tracer, TraceRecord } from './rtc';
-import { flatten, getSdkName, getSdkVersion } from './utils';
+import { PendingDelta, Tracer, TraceRecord } from './rtc';
+import { getSdkName, getSdkVersion } from './utils';
 import { getDeviceState, getWebRTCInfo } from '../helpers/client-details';
 import { hasPending, withoutConcurrency } from '../helpers/concurrency';
 import { timeboxed } from '../coordinator/connection/utils';
 import {
   ClientDetails,
-  InputDevices,
+  PerformanceStats,
   WebsocketReconnectStrategy,
 } from '../gen/video/sfu/models/models';
-import { CameraManager, MicrophoneManager } from '../devices';
-import { createSubscription } from '../store/rxUtils';
-import { CallState } from '../store';
 import { Telemetry } from '../gen/video/sfu/signal_rpc/signal';
 import { videoLoggerSystem } from '../logger';
 
@@ -23,9 +19,6 @@ export type SfuStatsReporterOptions = {
   clientDetails: ClientDetails;
   subscriber: Subscriber;
   publisher?: Publisher;
-  microphone: MicrophoneManager;
-  camera: CameraManager;
-  state: CallState;
   tracer: Tracer;
   unifiedSessionId: string;
 };
@@ -38,21 +31,15 @@ export class SfuStatsReporter {
   private readonly sfuClient: StreamSfuClient;
   private readonly subscriber: Subscriber;
   private readonly publisher?: Publisher;
-  private readonly microphone: MicrophoneManager;
-  private readonly camera: CameraManager;
-  private readonly state: CallState;
   private readonly tracer: Tracer;
   private readonly unifiedSessionId: string;
 
   private intervalId: NodeJS.Timeout | undefined;
   private timeoutId: NodeJS.Timeout | undefined;
   private reportCount: number = 0;
-  private unsubscribeDevicePermissionsSubscription?: () => void;
-  private unsubscribeListDevicesSubscription?: () => void;
   private readonly sdkName: string;
   private readonly sdkVersion: string;
   private readonly webRTCVersion: string;
-  private readonly inputDevices = new Map<'mic' | 'camera', InputDevices>();
   private readonly statsConcurrencyTag = Symbol('sfuStatsReporter');
   private isStopped = false;
 
@@ -63,9 +50,6 @@ export class SfuStatsReporter {
       clientDetails,
       subscriber,
       publisher,
-      microphone,
-      camera,
-      state,
       tracer,
       unifiedSessionId,
     }: SfuStatsReporterOptions,
@@ -74,9 +58,6 @@ export class SfuStatsReporter {
     this.options = options;
     this.subscriber = subscriber;
     this.publisher = publisher;
-    this.microphone = microphone;
-    this.camera = camera;
-    this.state = state;
     this.tracer = tracer;
     this.unifiedSessionId = unifiedSessionId;
 
@@ -93,46 +74,6 @@ export class SfuStatsReporter {
       'N/A';
   }
 
-  private observeDevice = (
-    device: CameraManager | MicrophoneManager,
-    kind: 'mic' | 'camera',
-  ) => {
-    const { browserPermissionState$ } = device.state;
-    this.unsubscribeDevicePermissionsSubscription?.();
-    this.unsubscribeDevicePermissionsSubscription = createSubscription(
-      combineLatest([browserPermissionState$, this.state.ownCapabilities$]),
-      ([browserPermissionState, ownCapabilities]) => {
-        // cleanup the previous listDevices() subscription in case
-        // permissions or capabilities have changed.
-        // we will subscribe again if everything is in order.
-        this.unsubscribeListDevicesSubscription?.();
-        const hasCapability =
-          kind === 'mic'
-            ? ownCapabilities.includes(OwnCapability.SEND_AUDIO)
-            : ownCapabilities.includes(OwnCapability.SEND_VIDEO);
-        if (browserPermissionState !== 'granted' || !hasCapability) {
-          this.inputDevices.set(kind, {
-            currentDevice: '',
-            availableDevices: [],
-            isPermitted: false,
-          });
-          return;
-        }
-        this.unsubscribeListDevicesSubscription = createSubscription(
-          combineLatest([device.listDevices(), device.state.selectedDevice$]),
-          ([devices, deviceId]) => {
-            const selected = devices.find((d) => d.deviceId === deviceId);
-            this.inputDevices.set(kind, {
-              currentDevice: selected?.label || deviceId || '',
-              availableDevices: devices.map((d) => d.label),
-              isPermitted: true,
-            });
-          },
-        );
-      },
-    );
-  };
-
   sendConnectionTime = (connectionTimeSeconds: number) => {
     this.sendTelemetryData({
       data: {
@@ -169,15 +110,17 @@ export class SfuStatsReporter {
    * explicit flush can capture the sample from live peer connections before
    * they are disposed, without waiting for an in-flight send.
    */
-  private sample = (): Promise<[ComputedStats, ComputedStats | undefined]> =>
+  private sample = (): Promise<
+    [PerformanceStats[], PerformanceStats[] | undefined]
+  > =>
     Promise.all([
       this.subscriber.stats.takeSample(),
       this.publisher?.stats.takeSample(),
     ]);
 
   private send = (
-    subscriberStats: ComputedStats,
-    publisherStats: ComputedStats | undefined,
+    subscriberPerfStats: PerformanceStats[],
+    publisherPerfStats: PerformanceStats[] | undefined,
     telemetry?: Telemetry,
   ) => {
     // serialize sends so overlapping ones can't race on the trace buffers or
@@ -196,8 +139,8 @@ export class SfuStatsReporter {
         this.subscriber.stats.clearPendingDeltas();
       }
       let pubPending: PendingDelta[] = [];
-      if (pubTracer && publisherStats) {
-        pubPending = this.publisher?.stats.getPendingDeltas() ?? [];
+      if (pubTracer && this.publisher) {
+        pubPending = this.publisher.stats.getPendingDeltas();
       } else {
         this.publisher?.stats.clearPendingDeltas();
       }
@@ -220,17 +163,9 @@ export class SfuStatsReporter {
           sdk: this.sdkName,
           sdkVersion: this.sdkVersion,
           webrtcVersion: this.webRTCVersion,
-          subscriberStats: JSON.stringify(flatten(subscriberStats.stats)),
-          publisherStats: publisherStats
-            ? JSON.stringify(flatten(publisherStats.stats))
-            : '[]',
-          subscriberRtcStats: '',
-          publisherRtcStats: '',
           rtcStats: JSON.stringify(traces),
-          encodeStats: publisherStats?.performanceStats ?? [],
-          decodeStats: subscriberStats.performanceStats,
-          audioDevices: this.inputDevices.get('mic'),
-          videoDevices: this.inputDevices.get('camera'),
+          encodeStats: publisherPerfStats ?? [],
+          decodeStats: subscriberPerfStats,
           unifiedSessionId: this.unifiedSessionId,
           deviceState: getDeviceState(),
           telemetry,
@@ -243,8 +178,8 @@ export class SfuStatsReporter {
         }
         // delivery confirmed: advance the delivery baseline for each chain.
         if (subTracer) this.subscriber.stats.commitDeltas(subPending);
-        if (pubTracer && publisherStats) {
-          this.publisher?.stats.commitDeltas(pubPending);
+        if (pubTracer && this.publisher) {
+          this.publisher.stats.commitDeltas(pubPending);
         }
       } catch (err) {
         // keep the delta chains (re-sent next interval); only the append-only
@@ -265,8 +200,8 @@ export class SfuStatsReporter {
    */
   private run = async (telemetry?: Telemetry) => {
     if (this.isStopped) return;
-    const [subscriberStats, publisherStats] = await this.sample();
-    await this.send(subscriberStats, publisherStats, telemetry);
+    const [subscriberPerfStats, publisherPerfStats] = await this.sample();
+    await this.send(subscriberPerfStats, publisherPerfStats, telemetry);
   };
 
   private scheduleNextReport = () => {
@@ -288,9 +223,6 @@ export class SfuStatsReporter {
   start = () => {
     if (this.options.reporting_interval_ms <= 0) return;
 
-    this.observeDevice(this.microphone, 'mic');
-    this.observeDevice(this.camera, 'camera');
-
     this.isStopped = false;
     this.reportCount = 0;
     clearInterval(this.intervalId);
@@ -301,12 +233,6 @@ export class SfuStatsReporter {
 
   stop = () => {
     this.isStopped = true;
-    this.unsubscribeDevicePermissionsSubscription?.();
-    this.unsubscribeDevicePermissionsSubscription = undefined;
-    this.unsubscribeListDevicesSubscription?.();
-    this.unsubscribeListDevicesSubscription = undefined;
-
-    this.inputDevices.clear();
     clearInterval(this.intervalId);
     this.intervalId = undefined;
     clearTimeout(this.timeoutId);
@@ -327,8 +253,8 @@ export class SfuStatsReporter {
     if (this.isStopped) return;
     try {
       const [sample] = await timeboxed([this.sample()], 2000);
-      const [subscriberStats, publisherStats] = sample;
-      this.send(subscriberStats, publisherStats).catch((err) => {
+      const [subscriberPerfStats, publisherPerfStats] = sample;
+      this.send(subscriberPerfStats, publisherPerfStats).catch((err) => {
         this.logger.warn('Failed to flush report stats', err);
       });
     } catch (err) {

package/src/stats/__tests__/SfuStatsReporter.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, it, vi } from 'vitest';
-import { BehaviorSubject } from 'rxjs';
 import { SfuStatsReporter } from '../SfuStatsReporter';
 import { promiseWithResolvers } from '../../helpers/promise';
 
@@ -9,10 +8,7 @@ const okResponse = { response: {} };
 const makeSlice = () => ({ snapshot: [] as unknown[], rollback: vi.fn() });
 
 const makeStats = (pending: Array<{ delta: object; ts: number }>) => ({
-  takeSample: vi.fn().mockResolvedValue({
-    performanceStats: [],
-    stats: new Map(),
-  }),
+  takeSample: vi.fn().mockResolvedValue([]),
   getPendingDeltas: vi.fn(() => pending),
   commitDeltas: vi.fn(),
   clearPendingDeltas: vi.fn(),
@@ -49,23 +45,11 @@ const build = (
   const sfuClient = { sendStats, getTrace: vi.fn(() => undefined) };
   const callTracer = { take: vi.fn(makeSlice), setEnabled: vi.fn() };
 
-  // device permission is 'denied' so observeDevice() doesn't reach listDevices()
-  const microphone = {
-    state: { browserPermissionState$: new BehaviorSubject('denied') },
-  };
-  const camera = {
-    state: { browserPermissionState$: new BehaviorSubject('denied') },
-  };
-  const state = { ownCapabilities$: new BehaviorSubject([]) };
-
   const reporter = new SfuStatsReporter(sfuClient as never, {
     options: { reporting_interval_ms: 1000, enable_rtc_stats: true } as never,
     clientDetails: { sdk: undefined, browser: undefined } as never,
     subscriber: subscriber as never,
     publisher: publisher as never,
-    microphone: microphone as never,
-    camera: camera as never,
-    state: state as never,
     tracer: callTracer as never,
     unifiedSessionId: 'unified',
   });
@@ -143,7 +127,7 @@ describe('SfuStatsReporter delta delivery', () => {
     await Promise.resolve();
     expect(resolved).toBe(false); // still sampling -> flush not resolved
 
-    dGet.resolve({ delta: {}, performanceStats: [], stats: new Map() });
+    dGet.resolve([]);
     await flushed;
     expect(resolved).toBe(true); // resolves after the sample, not the send
   });

package/src/stats/rtc/StatsTracer.ts

@@ -5,7 +5,7 @@ import {
   TrackType,
 } from '../../gen/video/sfu/models/models';
 import type { RTCCodecStats, RTCMediaSourceStats } from '../types';
-import type { ComputedStats, PendingDelta } from './types';
+import type { PendingDelta } from './types';
 import { withoutConcurrency } from '../../helpers/concurrency';
 
 /**
@@ -60,13 +60,13 @@ export class StatsTracer {
   }
 
   /**
-   * Samples the RTCPeerConnection: returns the current stats report and the
-   * derived performance stats, and appends the delta-compressed sample to the
-   * un-acked delivery chain (retrieved via `getPendingDeltas`).
+   * Samples the RTCPeerConnection: returns the derived performance stats and
+   * appends the delta-compressed sample to the un-acked delivery chain
+   * (retrieved via `getPendingDeltas`).
    *
    * @internal
    */
-  takeSample = (): Promise<ComputedStats> => {
+  takeSample = (): Promise<PerformanceStats[]> => {
     return withoutConcurrency(this.sampleTag, async () => {
       const stats = await this.pc.getStats();
       const now = Date.now();
@@ -98,7 +98,7 @@ export class StatsTracer {
       this.frameTimeHistory = this.frameTimeHistory.slice(-2);
       this.fpsHistory = this.fpsHistory.slice(-2);
 
-      return { performanceStats, stats };
+      return performanceStats;
     });
   };
 

package/src/stats/rtc/types.ts

@@ -1,5 +1,3 @@
-import type { PerformanceStats } from '../../gen/video/sfu/models/models';
-
 export type RTCStatsDataType =
   | RTCConfiguration
   | RTCIceCandidate
@@ -41,17 +39,6 @@ export type TraceSlice = {
   rollback: () => void;
 };
 
-export type ComputedStats = {
-  /**
-   * Current stats from the RTCPeerConnection.
-   */
-  stats: RTCStatsReport;
-  /**
-   * The current iteration of the stats.
-   */
-  performanceStats: PerformanceStats[];
-};
-
 /**
  * A single, not-yet-delivered delta-compressed stats sample.
  * The `delta` is computed against the immediately preceding sample, so a