@stream-io/video-client 1.58.0 → 1.59.1

package/src/devices/DeviceManager.ts

@@ -842,7 +842,10 @@ export abstract class DeviceManager<
     writePreferences(currentDevice, deviceKey, muted, storageKey);
   }
 
-  protected async applyPersistedPreferences(enabledInCallType: boolean) {
+  protected async applyPersistedPreferences(
+    enabledInCallType: boolean,
+    forceDisabled = false,
+  ) {
     const deviceKey: DevicePreferenceKey =
       this.trackType === TrackType.AUDIO ? 'microphone' : 'camera';
     const preferences = readPreferences(this.devicePersistence.storageKey);
@@ -875,15 +878,15 @@ export abstract class DeviceManager<
 
     const canPublish = this.call.permissionsContext.canPublish(this.trackType);
     if (typeof muted === 'boolean' && enabledInCallType && canPublish) {
-      await this.applyMutedState(muted);
+      await this.applyMutedState(muted, forceDisabled);
       appliedMute = true;
     }
 
     return appliedDevice || appliedMute;
   }
 
-  private async applyMutedState(muted: boolean) {
-    if (this.state.status !== undefined) return;
+  private async applyMutedState(muted: boolean, forceDisabled: boolean) {
+    if (forceDisabled || this.state.status !== undefined) return;
     if (muted) {
       await this.disable();
     } else {

package/src/devices/MicrophoneManager.ts

@@ -388,8 +388,13 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
    * Applies the audio settings to the microphone.
    * @param settings the audio settings to apply.
    * @param publish whether to publish the stream after applying the settings.
+   * @param forceDisabled whether to keep the mic disabled, regardless of server-side or local preferences.
    */
-  async apply(settings: AudioSettingsResponse, publish: boolean) {
+  async apply(
+    settings: AudioSettingsResponse,
+    publish: boolean,
+    forceDisabled: boolean = false,
+  ) {
     // Wait for any in progress mic operation
     await this.statusChangeSettled();
 
@@ -407,12 +412,15 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
       this.devicePersistence.enabled &&
       permissionState === 'granted'
     ) {
-      persistedPreferencesApplied = await this.applyPersistedPreferences(true);
+      persistedPreferencesApplied = await this.applyPersistedPreferences(
+        true,
+        forceDisabled,
+      );
     }
 
     const canPublish = this.call.permissionsContext.canPublish(this.trackType);
     if (shouldApplyDefaults && !persistedPreferencesApplied) {
-      if (canPublish && settings.mic_default_on) {
+      if (!forceDisabled && canPublish && settings.mic_default_on) {
         await this.enable();
       }
     }

package/src/devices/__tests__/CameraManager.test.ts

@@ -357,11 +357,37 @@ describe('CameraManager', () => {
         true,
       );
 
-      expect(applySpy).toHaveBeenCalledWith(true);
+      expect(applySpy).toHaveBeenCalledWith(true, false);
       expect(selectDirectionSpy).not.toHaveBeenCalled();
       expect(enableSpy).not.toHaveBeenCalled();
     });
 
+    it('should apply persisted device preferences without enabling when forced disabled', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
+      const devicePersistence = { enabled: true, storageKey: '' };
+      const persistedManager = new CameraManager(call, devicePersistence);
+      const applySpy = vi
+        .spyOn(persistedManager as never, 'applyPersistedPreferences')
+        .mockResolvedValue(true);
+      const enableSpy = vi.spyOn(persistedManager, 'enable');
+
+      await persistedManager.apply(
+        fromPartial({
+          enabled: true,
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: true,
+        }),
+        false,
+        true,
+      );
+
+      expect(applySpy).toHaveBeenCalledWith(true, true);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
     it('should skip persisted preferences when permission is not granted', async () => {
       vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
         of('prompt'),

package/src/devices/__tests__/DeviceManager.test.ts

@@ -21,7 +21,7 @@ import { DeviceManagerState } from '../DeviceManagerState';
 import { firstValueFrom, of } from 'rxjs';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { PermissionsContext } from '../../permissions';
-import { readPreferences } from '../devicePersistence';
+import { defaultDeviceId, readPreferences } from '../devicePersistence';
 
 vi.mock('../../reporting/ClientEventReporter', () => ({
   ClientEventReporter: vi.fn(function () {
@@ -1010,6 +1010,54 @@ describe('Device Manager', () => {
       expect(selectSpy).toHaveBeenCalledWith(mockVideoDevices[1].deviceId);
     });
 
+    it('selects the device without unmuting when forced disabled', async () => {
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          camera: [
+            {
+              selectedDeviceId: mockVideoDevices[0].deviceId,
+              selectedDeviceLabel: mockVideoDevices[0].label,
+              muted: false,
+            },
+          ],
+        }),
+      );
+
+      const selectSpy = vi.spyOn(manager, 'select');
+      const enableSpy = vi.spyOn(manager, 'enable');
+
+      // @ts-expect-error - private API
+      const result = await manager.applyPersistedPreferences(true, true);
+
+      expect(result).toBe(true);
+      expect(selectSpy).toHaveBeenCalledWith(mockVideoDevices[0].deviceId);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
+    it('retains a default-device mute preference when forced disabled', async () => {
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          camera: [
+            {
+              selectedDeviceId: defaultDeviceId,
+              selectedDeviceLabel: '',
+              muted: false,
+            },
+          ],
+        }),
+      );
+
+      const enableSpy = vi.spyOn(manager, 'enable');
+
+      // @ts-expect-error - private API
+      const result = await manager.applyPersistedPreferences(true, true);
+
+      expect(result).toBe(true);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
     it('applies muted state without selecting when default device is stored', async () => {
       localStorageMock.setItem(
         storageKey,

package/src/devices/__tests__/MicrophoneManager.test.ts

@@ -486,7 +486,29 @@ describe('MicrophoneManager', () => {
       // @ts-expect-error - partial data
       await persistedManager.apply({ mic_default_on: true }, true);
 
-      expect(applySpy).toHaveBeenCalledWith(true);
+      expect(applySpy).toHaveBeenCalledWith(true, false);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
+    it('should apply persisted device preferences without enabling when forced disabled', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
+      const devicePersistence = { enabled: true, storageKey: '' };
+      const persistedManager = new MicrophoneManager(
+        call,
+        devicePersistence,
+        'disable-tracks',
+      );
+      const applySpy = vi
+        .spyOn(persistedManager as never, 'applyPersistedPreferences')
+        .mockResolvedValue(true);
+      const enableSpy = vi.spyOn(persistedManager, 'enable');
+
+      // @ts-expect-error - partial data
+      await persistedManager.apply({ mic_default_on: true }, false, true);
+
+      expect(applySpy).toHaveBeenCalledWith(true, true);
       expect(enableSpy).not.toHaveBeenCalled();
     });
 

package/src/events/call.ts

@@ -81,7 +81,6 @@ export const watchCallRejected = (call: Call) => {
  */
 export const watchCallEnded = (call: Call) => {
   return function onCallEnded() {
-    globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
     const { callingState } = call.state;
     if (
       callingState !== CallingState.IDLE &&
@@ -92,9 +91,13 @@ export const watchCallEnded = (call: Call) => {
         reason: 'call.ended event received',
       });
       call
-        .leave({ message: 'call.ended event received', reject: false })
+        .leave({
+          message: 'call.ended event received',
+          reject: false,
+          reason: 'ended',
+        })
         .catch((err) => {
-          call.logger.error('Failed to leave call after call.ended ', err);
+          call.logger.error('Failed to leave call after call.ended', err);
         });
     }
   };

package/src/gen/coordinator/index.ts

@@ -8468,6 +8468,32 @@ export interface ReportByHistogramBucket {
    */
   upper_bound?: Bound;
 }
+/**
+ * Reports a batch of client-side telemetry events. Each event is validated and processed independently; one invalid event does not block the rest of the batch.
+ * @export
+ * @interface ReportClientEventRequest
+ */
+export interface ReportClientEventRequest {
+  /**
+   * Client-side events to report (1-100 per request)
+   * @type {Array<ClientEvent>}
+   * @memberof ReportClientEventRequest
+   */
+  events: Array<ClientEvent>;
+}
+/**
+ * Response for reporting client-side telemetry events
+ * @export
+ * @interface ReportClientEventResponse
+ */
+export interface ReportClientEventResponse {
+  /**
+   * Duration of the request in milliseconds
+   * @type {string}
+   * @memberof ReportClientEventResponse
+   */
+  duration: string;
+}
 /**
  *
  * @export

package/src/helpers/MediaStreamRecorder.ts

@@ -0,0 +1,104 @@
+import { videoLoggerSystem } from '../logger';
+import { promiseWithResolvers } from './promise';
+
+export type MediaStreamRecorderOptions = {
+  /** Auto-stop after this many milliseconds. */
+  maxDurationMs?: number;
+};
+
+export type MediaRecordingResult = {
+  blob: Blob;
+};
+
+/** Single-use `MediaRecorder` wrapper that returns an in-memory blob. */
+export class MediaStreamRecorder {
+  private recording = promiseWithResolvers<MediaRecordingResult | null>();
+  private logger = videoLoggerSystem.getLogger('MediaStreamRecorder');
+  private chunks: Blob[] = [];
+  private timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  private recorder: MediaRecorder;
+  private readonly tracks: MediaStreamTrack[];
+  private readonly maxDurationMs: number | undefined;
+
+  constructor(stream: MediaStream, options: MediaStreamRecorderOptions = {}) {
+    if (typeof MediaRecorder === 'undefined') {
+      throw new Error('MediaRecorder is not available in this environment');
+    }
+
+    this.tracks = stream.getTracks();
+    if (this.tracks.length === 0) {
+      throw new Error('cannot record a MediaStream that has no tracks');
+    }
+
+    this.maxDurationMs = options.maxDurationMs;
+    this.recorder = new MediaRecorder(new MediaStream(this.tracks));
+
+    this.recorder.ondataavailable = (event: BlobEvent) => {
+      if (event.data?.size) this.chunks.push(event.data);
+    };
+
+    this.recorder.onstop = this.handleStop;
+    this.recorder.onerror = this.handleError;
+  }
+
+  /** Starts recording and resolves when recording stops. */
+  start = (): Promise<MediaRecordingResult | null> => {
+    if (this.isSettled()) {
+      throw new Error(
+        'MediaStreamRecorder is single-use: this instance has already ' +
+          'recorded. Construct a new one.',
+      );
+    }
+
+    if (this.recorder.state === 'inactive') {
+      this.tracks.forEach((track) =>
+        track.addEventListener('ended', this.stop),
+      );
+      if (this.maxDurationMs !== undefined) {
+        this.timeoutId = setTimeout(this.stop, this.maxDurationMs);
+      }
+      this.recorder.start();
+    }
+
+    return this.recording.promise;
+  };
+
+  /** Stops recording early. */
+  stop = (): void => {
+    if (this.recorder.state !== 'inactive') this.recorder.stop();
+  };
+
+  private isSettled = () =>
+    this.recording.isResolved() || this.recording.isRejected();
+
+  private detach = () => {
+    clearTimeout(this.timeoutId);
+    this.tracks.forEach((track) =>
+      track.removeEventListener('ended', this.stop),
+    );
+  };
+
+  private handleStop = () => {
+    this.detach();
+
+    if (this.chunks.length === 0) {
+      this.logger.warn('MediaRecorder recording produced no data');
+      this.recording.resolve(null);
+      return;
+    }
+
+    const mimeType = this.chunks[0].type || this.recorder.mimeType;
+    this.recording.resolve({
+      blob: new Blob(this.chunks, { type: mimeType }),
+    });
+  };
+
+  private handleError = (event: Event) => {
+    if (this.isSettled()) return;
+    this.detach();
+    const error = (event as unknown as { error?: DOMException }).error;
+    this.logger.error('MediaRecorder error', error);
+    this.recording.reject(error ?? new Error('MediaRecorder failed'));
+  };
+}

package/src/helpers/__tests__/MediaStreamRecorder.test.ts

@@ -0,0 +1,324 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
+import { MediaStreamRecorder } from '../MediaStreamRecorder';
+import { videoLoggerSystem } from '../../logger';
+
+const createTrack = (kind: 'audio' | 'video' = 'video') => {
+  const events = new EventTarget();
+  return fromPartial<MediaStreamTrack>({
+    kind,
+    id: `${kind}-track`,
+    readyState: 'live',
+    stop: vi.fn(),
+    addEventListener: events.addEventListener.bind(events),
+    removeEventListener: events.removeEventListener.bind(events),
+    dispatchEvent: events.dispatchEvent.bind(events),
+  });
+};
+
+class FakeMediaStream {
+  private tracks: MediaStreamTrack[];
+
+  constructor(tracks: MediaStreamTrack[] = []) {
+    this.tracks = [...tracks];
+  }
+
+  getTracks = () => [...this.tracks];
+  addTrack = (track: MediaStreamTrack) => this.tracks.push(track);
+}
+
+const createStream = (...tracks: MediaStreamTrack[]) =>
+  new FakeMediaStream(tracks) as unknown as MediaStream;
+
+class FakeMediaRecorder {
+  static instances: FakeMediaRecorder[] = [];
+  static isTypeSupported = vi.fn(() => true);
+
+  stream: MediaStream;
+  options: MediaRecorderOptions | undefined;
+  state: 'inactive' | 'recording' | 'paused' = 'inactive';
+  mimeType: string;
+  ondataavailable: ((event: BlobEvent) => void) | null = null;
+  onstop: (() => void) | null = null;
+  onerror: ((event: Event) => void) | null = null;
+
+  finalChunks: Blob[] = [new Blob(['payload'], { type: 'video/webm' })];
+
+  constructor(stream: MediaStream, options?: MediaRecorderOptions) {
+    this.stream = stream;
+    this.options = options;
+    this.mimeType = options?.mimeType ?? 'video/webm;codecs=vp8,opus';
+    FakeMediaRecorder.instances.push(this);
+  }
+
+  start = vi.fn(() => {
+    this.state = 'recording';
+  });
+
+  stop = vi.fn(() => {
+    if (this.state === 'inactive') return;
+    this.state = 'inactive';
+    this.finalChunks.forEach((data) => this.emitData(data));
+    this.onstop?.();
+  });
+
+  emitData = (data: Blob) => {
+    this.ondataavailable?.(fromPartial<BlobEvent>({ data }));
+  };
+}
+
+const lastRecorder = () =>
+  FakeMediaRecorder.instances[FakeMediaRecorder.instances.length - 1];
+
+describe('MediaStreamRecorder', () => {
+  let logger: { debug: any; warn: any; error: any };
+
+  beforeEach(() => {
+    FakeMediaRecorder.instances = [];
+    vi.stubGlobal('MediaRecorder', FakeMediaRecorder);
+    vi.stubGlobal('MediaStream', FakeMediaStream);
+    logger = { debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    vi.spyOn(videoLoggerSystem, 'getLogger').mockReturnValue(
+      fromPartial(logger),
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe('construction', () => {
+    it('throws when MediaRecorder is unavailable', () => {
+      vi.stubGlobal('MediaRecorder', undefined);
+      expect(
+        () => new MediaStreamRecorder(createStream(createTrack())),
+      ).toThrow(/MediaRecorder is not available/);
+    });
+
+    it('throws when the stream has no tracks', () => {
+      expect(() => new MediaStreamRecorder(createStream())).toThrow(
+        /has no tracks/,
+      );
+    });
+
+    it('lets the browser choose the recording MIME type', () => {
+      new MediaStreamRecorder(createStream(createTrack()));
+
+      expect(lastRecorder().options).toBeUndefined();
+    });
+
+    it('does not start recording until `start` is called', () => {
+      new MediaStreamRecorder(createStream(createTrack()));
+
+      expect(lastRecorder().start).not.toHaveBeenCalled();
+    });
+
+    it('creates no DOM elements of its own', () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      recorder.start();
+      expect(document.querySelectorAll('video, audio')).toHaveLength(0);
+    });
+
+    it('records a snapshot, so mutating the caller stream cannot disturb it', () => {
+      const track = createTrack();
+      const stream = createStream(track);
+      new MediaStreamRecorder(stream);
+
+      stream.addTrack(createTrack('audio'));
+
+      expect(lastRecorder().stream).not.toBe(stream);
+      expect(lastRecorder().stream.getTracks()).toEqual([track]);
+    });
+  });
+
+  describe('recording', () => {
+    it('resolves with the recorded blob', async () => {
+      vi.useFakeTimers();
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+
+      const recording = recorder.start();
+      vi.advanceTimersByTime(2500);
+      recorder.stop();
+
+      const result = await recording;
+
+      expect(result?.blob.size).toBeGreaterThan(0);
+      expect(result?.blob.type).toBe('video/webm');
+    });
+
+    it('hands every awaiter of `start` the same result', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+
+      const first = recorder.start();
+      const second = recorder.start();
+      recorder.stop();
+
+      expect(await first).toBe(await second);
+      expect(lastRecorder().start).toHaveBeenCalledTimes(1);
+    });
+
+    it('sets the blob type from the recorder when the chunk carries none', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      lastRecorder().finalChunks = [new Blob(['payload'])];
+
+      const recording = recorder.start();
+      recorder.stop();
+
+      expect((await recording)?.blob.type).toBe('video/webm;codecs=vp8,opus');
+    });
+
+    it('keeps chunks that arrive before stop', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      const recording = recorder.start();
+      lastRecorder().emitData(new Blob(['early'], { type: 'video/webm' }));
+
+      recorder.stop();
+
+      expect((await recording)?.blob.size).toBe(12);
+    });
+
+    it('ignores empty chunks', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      const recording = recorder.start();
+      lastRecorder().emitData(new Blob([]));
+      lastRecorder().finalChunks = [];
+
+      recorder.stop();
+
+      await expect(recording).resolves.toBeNull();
+    });
+
+    it('resolves null and warns when nothing was captured', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      lastRecorder().finalChunks = [];
+
+      const recording = recorder.start();
+      recorder.stop();
+
+      await expect(recording).resolves.toBeNull();
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('recording produced no data'),
+      );
+    });
+
+    it('never stops the tracks it was handed', async () => {
+      const track = createTrack();
+      const recorder = new MediaStreamRecorder(createStream(track));
+
+      const recording = recorder.start();
+      recorder.stop();
+      await recording;
+
+      expect(track.stop).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('auto-stop', () => {
+    it('stops once maxDurationMs elapses', async () => {
+      vi.useFakeTimers();
+      const recorder = new MediaStreamRecorder(createStream(createTrack()), {
+        maxDurationMs: 5000,
+      });
+
+      const recording = recorder.start();
+      vi.advanceTimersByTime(5000);
+
+      await expect(recording).resolves.toMatchObject({
+        blob: expect.any(Blob),
+      });
+    });
+
+    it('runs indefinitely when maxDurationMs is omitted', async () => {
+      vi.useFakeTimers();
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+
+      const recording = recorder.start();
+      vi.advanceTimersByTime(10 * 60 * 1000);
+
+      expect(lastRecorder().stop).not.toHaveBeenCalled();
+      recorder.stop();
+      await recording;
+    });
+
+    it('stops when any source track ends, keeping what was captured', async () => {
+      const audioTrack = createTrack('audio');
+      const recorder = new MediaStreamRecorder(
+        createStream(createTrack(), audioTrack),
+      );
+
+      const recording = recorder.start();
+      audioTrack.dispatchEvent(new Event('ended'));
+
+      await expect(recording).resolves.toMatchObject({
+        blob: expect.any(Blob),
+      });
+    });
+
+    it('resolves when the user agent stops the recorder on its own', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      const recording = recorder.start();
+
+      lastRecorder().stop();
+
+      await expect(recording).resolves.toMatchObject({
+        blob: expect.any(Blob),
+      });
+    });
+  });
+
+  describe('lifecycle guards', () => {
+    it('is a no-op when stopped before it was started', () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+
+      expect(() => recorder.stop()).not.toThrow();
+      expect(lastRecorder().stop).not.toHaveBeenCalled();
+      expect(lastRecorder().start).not.toHaveBeenCalled();
+    });
+
+    it('throws when restarted after finishing', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      const recording = recorder.start();
+      recorder.stop();
+      await recording;
+
+      expect(() => recorder.start()).toThrow(/single-use/);
+    });
+
+    it('is idempotent across repeated stops', async () => {
+      const recorder = new MediaStreamRecorder(createStream(createTrack()));
+      const recording = recorder.start();
+
+      recorder.stop();
+      recorder.stop();
+
+      await expect(recording).resolves.toMatchObject({
+        blob: expect.any(Blob),
+      });
+      expect(lastRecorder().stop).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it('leaves no timer or listener behind after finishing', async () => {
+    vi.useFakeTimers();
+    const track = createTrack();
+    const recorder = new MediaStreamRecorder(createStream(track), {
+      maxDurationMs: 5000,
+    });
+
+    const recording = recorder.start();
+    recorder.stop();
+    const result = await recording;
+
+    expect(() => {
+      vi.advanceTimersByTime(10_000);
+      track.dispatchEvent(new Event('ended'));
+    }).not.toThrow();
+    expect(lastRecorder().stop).toHaveBeenCalledTimes(1);
+    expect(result?.blob).toBeInstanceOf(Blob);
+  });
+});