@stream-io/video-client 1.14.0 → 1.15.1

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

@@ -14,6 +14,7 @@ import { getVideoStream } from '../devices';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { CameraManager } from '../CameraManager';
 import { of } from 'rxjs';
+import { PermissionsContext } from '../../permissions';
 
 vi.mock('../devices.ts', () => {
   console.log('MOCKING devices API');
@@ -36,7 +37,7 @@ vi.mock('../../Call.ts', () => {
   };
 });
 
-vi.mock('../../compatibility.ts', () => {
+vi.mock('../../helpers/compatibility.ts', () => {
   console.log('MOCKING mobile device');
   return {
     isMobile: () => true,
@@ -52,16 +53,16 @@ vi.mock('../../helpers/platforms', () => {
 
 describe('CameraManager', () => {
   let manager: CameraManager;
+  let call: Call;
 
   beforeEach(() => {
-    manager = new CameraManager(
-      new Call({
-        id: '',
-        type: '',
-        streamClient: new StreamClient('abc123'),
-        clientStore: new StreamVideoWriteableStateStore(),
-      }),
-    );
+    call = new Call({
+      id: '',
+      type: '',
+      streamClient: new StreamClient('abc123'),
+      clientStore: new StreamVideoWriteableStateStore(),
+    });
+    manager = new CameraManager(call);
   });
 
   it('list devices', () => {
@@ -94,8 +95,9 @@ describe('CameraManager', () => {
 
     await manager.enable();
 
-    expect(manager['call'].publishVideoStream).toHaveBeenCalledWith(
+    expect(manager['call'].publish).toHaveBeenCalledWith(
       manager.state.mediaStream,
+      TrackType.VIDEO,
     );
   });
 
@@ -105,10 +107,7 @@ describe('CameraManager', () => {
 
     await manager.disable();
 
-    expect(manager['call'].stopPublish).toHaveBeenCalledWith(
-      TrackType.VIDEO,
-      true,
-    );
+    expect(manager['call'].stopPublish).toHaveBeenCalledWith(TrackType.VIDEO);
   });
 
   it('flip', async () => {
@@ -205,6 +204,104 @@ describe('CameraManager', () => {
     expect(getVideoStream).toHaveBeenCalledOnce();
   });
 
+  describe('Video Settings', () => {
+    beforeEach(() => {
+      // @ts-expect-error - read only property
+      call.permissionsContext = new PermissionsContext();
+      call.permissionsContext.hasPermission = vi.fn().mockReturnValue(true);
+    });
+
+    it('should enable the camera when set on the dashboard', async () => {
+      vi.spyOn(manager, 'enable');
+      await manager.apply(
+        // @ts-expect-error - partial settings
+        {
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: true,
+        },
+        true,
+      );
+
+      expect(manager.state.direction).toBe('front');
+      expect(manager.state.status).toBe('enabled');
+      expect(manager['targetResolution']).toEqual({ width: 640, height: 480 });
+      expect(manager.enable).toHaveBeenCalled();
+    });
+
+    it('should not enable the camera when set on the dashboard', async () => {
+      vi.spyOn(manager, 'enable');
+      await manager.apply(
+        // @ts-expect-error - partial settings
+        {
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: false,
+        },
+        true,
+      );
+
+      expect(manager.state.direction).toBe('front');
+      expect(manager.state.status).toBe(undefined);
+      expect(manager['targetResolution']).toEqual({ width: 640, height: 480 });
+      expect(manager.enable).not.toHaveBeenCalled();
+    });
+
+    it('should not turn on the camera when publish is false', async () => {
+      vi.spyOn(manager, 'enable');
+      await manager.apply(
+        // @ts-expect-error - partial settings
+        {
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: true,
+        },
+        false,
+      );
+
+      expect(manager.state.direction).toBe('front');
+      expect(manager.state.status).toBe(undefined);
+      expect(manager['targetResolution']).toEqual({ width: 640, height: 480 });
+      expect(manager.enable).not.toHaveBeenCalled();
+    });
+
+    it('should not enable the camera when the user does not have permission', async () => {
+      call.permissionsContext.hasPermission = vi.fn().mockReturnValue(false);
+      vi.spyOn(manager, 'enable');
+      await manager.apply(
+        // @ts-expect-error - partial settings
+        {
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: true,
+        },
+        true,
+      );
+
+      expect(manager.state.direction).toBe(undefined);
+      expect(manager.state.status).toBe(undefined);
+      expect(manager['targetResolution']).toEqual({ width: 1280, height: 720 });
+      expect(manager.enable).not.toHaveBeenCalled();
+    });
+
+    it('should publish the stream when the camera is already enabled', async () => {
+      await manager.enable();
+      // @ts-expect-error - private api
+      vi.spyOn(manager, 'publishStream');
+      await manager.apply(
+        // @ts-expect-error - partial settings
+        {
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: true,
+        },
+        true,
+      );
+
+      expect(manager['publishStream']).toHaveBeenCalled();
+    });
+  });
+
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();

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

@@ -4,11 +4,11 @@ import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
-  MockTrack,
   emitDeviceIds,
   mockBrowserPermission,
   mockCall,
   mockDeviceIds$,
+  MockTrack,
   mockVideoDevices,
   mockVideoStream,
 } from './mocks';
@@ -123,7 +123,7 @@ describe('InputMediaDeviceManager.test', () => {
 
     await manager.disable();
 
-    expect(manager.stopPublishStream).toHaveBeenCalledWith(true);
+    expect(manager.stopPublishStream).toHaveBeenCalled();
   });
 
   it('disable device with forceStop', async () => {
@@ -134,7 +134,7 @@ describe('InputMediaDeviceManager.test', () => {
 
     await manager.disable(true);
 
-    expect(manager.stopPublishStream).toHaveBeenCalledWith(true);
+    expect(manager.stopPublishStream).toHaveBeenCalled();
     expect(manager.state.mediaStream).toBeUndefined();
     expect(manager.state.status).toBe('disabled');
   });
@@ -179,7 +179,7 @@ describe('InputMediaDeviceManager.test', () => {
     const deviceId = mockVideoDevices[1].deviceId;
     await manager.select(deviceId);
 
-    expect(manager.stopPublishStream).toHaveBeenCalledWith(true);
+    expect(manager.stopPublishStream).toHaveBeenCalled();
     expect(manager.getStream).toHaveBeenCalledWith({
       deviceId: { exact: deviceId },
     });

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

@@ -23,6 +23,7 @@ import {
   createSoundDetector,
   SoundStateChangeHandler,
 } from '../../helpers/sound-detector';
+import { PermissionsContext } from '../../permissions';
 
 vi.mock('../devices.ts', () => {
   console.log('MOCKING devices API');
@@ -60,7 +61,7 @@ class NoiseCancellationStub implements INoiseCancellation {
   enable = () => this.listeners['change']?.forEach((l) => l(true));
   disable = () => this.listeners['change']?.forEach((l) => l(false));
   dispose = () => Promise.resolve(undefined);
-  toFilter = () => async (ms: MediaStream) => ms;
+  toFilter = () => (ms: MediaStream) => ({ output: ms });
   on = (event, callback) => {
     (this.listeners[event] ??= []).push(callback);
     return () => {};
@@ -70,17 +71,16 @@ class NoiseCancellationStub implements INoiseCancellation {
 
 describe('MicrophoneManager', () => {
   let manager: MicrophoneManager;
+  let call: Call;
 
   beforeEach(() => {
-    manager = new MicrophoneManager(
-      new Call({
-        id: '',
-        type: '',
-        streamClient: new StreamClient('abc123'),
-        clientStore: new StreamVideoWriteableStateStore(),
-      }),
-      'disable-tracks',
-    );
+    call = new Call({
+      id: '',
+      type: '',
+      streamClient: new StreamClient('abc123'),
+      clientStore: new StreamVideoWriteableStateStore(),
+    });
+    manager = new MicrophoneManager(call, 'disable-tracks');
   });
   it('list devices', () => {
     const spy = vi.fn();
@@ -110,8 +110,9 @@ describe('MicrophoneManager', () => {
 
     await manager.enable();
 
-    expect(manager['call'].publishAudioStream).toHaveBeenCalledWith(
+    expect(manager['call'].publish).toHaveBeenCalledWith(
       manager.state.mediaStream,
+      TrackType.AUDIO,
     );
   });
 
@@ -121,10 +122,7 @@ describe('MicrophoneManager', () => {
 
     await manager.disable();
 
-    expect(manager['call'].stopPublish).toHaveBeenCalledWith(
-      TrackType.AUDIO,
-      false,
-    );
+    expect(manager['call'].stopPublish).toHaveBeenCalledWith(TrackType.AUDIO);
   });
 
   it('disable-enable mic should set track.enabled', async () => {
@@ -244,7 +242,6 @@ describe('MicrophoneManager', () => {
 
   describe('Noise Cancellation', () => {
     it('should register filter if all preconditions are met', async () => {
-      const call = manager['call'];
       call.state.setCallingState(CallingState.IDLE);
       const registerFilter = vi.spyOn(manager, 'registerFilter');
       const noiseCancellation = new NoiseCancellationStub();
@@ -259,12 +256,10 @@ describe('MicrophoneManager', () => {
       const noiseCancellation = new NoiseCancellationStub();
       await manager.enableNoiseCancellation(noiseCancellation);
       await manager.disableNoiseCancellation();
-      const call = manager['call'];
       expect(call.notifyNoiseCancellationStopped).toBeCalled();
     });
 
     it('should throw when own capabilities are missing', async () => {
-      const call = manager['call'];
       call.state.setOwnCapabilities([]);
 
       await expect(() =>
@@ -273,7 +268,6 @@ describe('MicrophoneManager', () => {
     });
 
     it('should throw when noise cancellation is disabled in call settings', async () => {
-      const call = manager['call'];
       call.state.setOwnCapabilities([OwnCapability.ENABLE_NOISE_CANCELLATION]);
       call.state.updateFromCallResponse({
         // @ts-expect-error partial data
@@ -289,7 +283,6 @@ describe('MicrophoneManager', () => {
     });
 
     it('should automatically enable noise noise suppression after joining a call', async () => {
-      const call = manager['call'];
       call.state.setCallingState(CallingState.IDLE); // reset state
       call.state.updateFromCallResponse({
         settings: {
@@ -320,7 +313,6 @@ describe('MicrophoneManager', () => {
     });
 
     it('should automatically disable noise suppression after leaving the call', async () => {
-      const call = manager['call'];
       const noiseCancellation = new NoiseCancellationStub();
       const noiseSuppressionDisable = vi.spyOn(noiseCancellation, 'disable');
       await manager.enableNoiseCancellation(noiseCancellation);
@@ -339,6 +331,52 @@ describe('MicrophoneManager', () => {
     });
   });
 
+  describe('Audio Settings', () => {
+    beforeEach(() => {
+      // @ts-expect-error - read only property
+      call.permissionsContext = new PermissionsContext();
+      call.permissionsContext.hasPermission = vi.fn().mockReturnValue(true);
+    });
+
+    it('should turn the mic on when set on dashboard', async () => {
+      const enable = vi.spyOn(manager, 'enable');
+      // @ts-expect-error - partial data
+      await manager.apply({ mic_default_on: true }, true);
+      expect(enable).toHaveBeenCalled();
+    });
+
+    it('should not turn the mic on when set on dashboard', async () => {
+      const enable = vi.spyOn(manager, 'enable');
+      // @ts-expect-error - partial data
+      await manager.apply({ mic_default_on: false }, true);
+      expect(enable).not.toHaveBeenCalled();
+    });
+
+    it('should not turn on the mic when publish is false', async () => {
+      const enable = vi.spyOn(manager, 'enable');
+      // @ts-expect-error - partial data
+      await manager.apply({ mic_default_on: true }, false);
+      expect(enable).not.toHaveBeenCalled();
+    });
+
+    it('should not turn on the mic when permission is missing', async () => {
+      call.permissionsContext.hasPermission = vi.fn().mockReturnValue(false);
+      const enable = vi.spyOn(manager, 'enable');
+      // @ts-expect-error - partial data
+      await manager.apply({ mic_default_on: true }, true);
+      expect(enable).not.toHaveBeenCalled();
+    });
+
+    it('should publish the audio stream when mic is turned on before settings are applied', async () => {
+      await manager.enable();
+      // @ts-expect-error - private api
+      vi.spyOn(manager, 'publishStream');
+      // @ts-expect-error - partial data
+      await manager.apply({ mic_default_on: true }, true);
+      expect(manager['publishStream']).toHaveBeenCalled();
+    });
+  });
+
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();

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

@@ -49,8 +49,8 @@ describe('ScreenShareManager', () => {
     expect(RxUtils.getCurrentValue(devices)).toEqual([]);
   });
 
-  it('select device', () => {
-    expect(manager.select('any-device-id')).rejects.toThrowError();
+  it('select device', async () => {
+    await expect(manager.select('any-device-id')).rejects.toThrowError();
   });
 
   it('get stream', async () => {
@@ -113,8 +113,9 @@ describe('ScreenShareManager', () => {
     const call = manager['call'];
     call.state.setCallingState(CallingState.JOINED);
     await manager.enable();
-    expect(call.publishScreenShareStream).toHaveBeenCalledWith(
+    expect(call.publish).toHaveBeenCalledWith(
       manager.state.mediaStream,
+      TrackType.SCREEN_SHARE,
     );
   });
 
@@ -125,10 +126,9 @@ describe('ScreenShareManager', () => {
 
     await manager.disable();
     expect(manager.state.status).toEqual('disabled');
-    expect(call.stopPublish).toHaveBeenCalledWith(TrackType.SCREEN_SHARE, true);
     expect(call.stopPublish).toHaveBeenCalledWith(
+      TrackType.SCREEN_SHARE,
       TrackType.SCREEN_SHARE_AUDIO,
-      true,
     );
   });
 });

package/src/devices/__tests__/mocks.ts

@@ -96,6 +96,7 @@ export const mockCall = (): Partial<Call> => {
     publishVideoStream: vi.fn(),
     publishAudioStream: vi.fn(),
     publishScreenShareStream: vi.fn(),
+    publish: vi.fn(),
     stopPublish: vi.fn(),
     notifyNoiseCancellationStarting: vi.fn().mockResolvedValue(undefined),
     notifyNoiseCancellationStopped: vi.fn().mockResolvedValue(undefined),

package/src/events/__tests__/internal.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it, vi } from 'vitest';
+import { Call } from '../../Call';
+import { Dispatcher } from '../../rtc';
+import { CallState } from '../../store';
+import {
+  watchConnectionQualityChanged,
+  watchLiveEnded,
+  watchParticipantCountChanged,
+  watchPinsUpdated,
+} from '../internal';
+import {
+  ConnectionQuality,
+  ErrorCode,
+} from '../../gen/video/sfu/models/models';
+
+describe('internal events', () => {
+  it('handles connectionQualityChanged', () => {
+    const state = new CallState();
+    const dispatcher = new Dispatcher();
+    state.setParticipants([
+      // @ts-expect-error
+      { sessionId: 'session-1', connectionQuality: ConnectionQuality.POOR },
+    ]);
+
+    watchConnectionQualityChanged(dispatcher, state);
+
+    dispatcher.dispatch({
+      eventPayload: {
+        oneofKind: 'connectionQualityChanged',
+        // @ts-expect-error
+        connectionQualityChanged: {
+          connectionQualityUpdates: [
+            {
+              sessionId: 'session-1',
+              connectionQuality: ConnectionQuality.EXCELLENT,
+            },
+          ],
+        },
+      },
+    });
+    expect(state.participants).toEqual([
+      {
+        sessionId: 'session-1',
+        connectionQuality: ConnectionQuality.EXCELLENT,
+      },
+    ]);
+  });
+
+  it('handles healthCheckResponse', () => {
+    const state = new CallState();
+    const dispatcher = new Dispatcher();
+    state.setParticipantCount(0);
+    state.setAnonymousParticipantCount(0);
+
+    watchParticipantCountChanged(dispatcher, state);
+
+    dispatcher.dispatch({
+      eventPayload: {
+        oneofKind: 'healthCheckResponse',
+        // @ts-expect-error
+        healthCheckResponse: {
+          participantCount: {
+            total: 5,
+            anonymous: 2,
+          },
+        },
+      },
+    });
+    expect(state.participantCount).toBe(5);
+    expect(state.anonymousParticipantCount).toBe(2);
+  });
+
+  it('handles liveEnded', () => {
+    const dispatcher = new Dispatcher();
+    const call = {
+      permissionsContext: { hasPermission: () => false },
+      leave: vi.fn().mockResolvedValue(undefined),
+      logger: vi.fn(),
+    } as unknown as Call;
+
+    watchLiveEnded(dispatcher, call);
+
+    dispatcher.dispatch({
+      eventPayload: {
+        oneofKind: 'error',
+        // @ts-expect-error
+        error: { code: ErrorCode.LIVE_ENDED },
+      },
+    });
+    expect(call.leave).toHaveBeenCalled();
+  });
+
+  it('handles liveEnded when user has permission to stay in backstage', () => {
+    const dispatcher = new Dispatcher();
+    const call = {
+      permissionsContext: { hasPermission: () => true },
+      leave: vi.fn().mockResolvedValue(undefined),
+      logger: vi.fn(),
+    } as unknown as Call;
+
+    watchLiveEnded(dispatcher, call);
+
+    dispatcher.dispatch({
+      eventPayload: {
+        oneofKind: 'error',
+        // @ts-expect-error
+        error: { code: ErrorCode.LIVE_ENDED },
+      },
+    });
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+
+  it('handles pinUpdated', () => {
+    const state = new CallState();
+    state.setParticipants([
+      // @ts-expect-error
+      { userId: 'u1', sessionId: 'session-1', pin: { isLocalPin: false } },
+      // @ts-expect-error
+      { userId: 'u2', sessionId: 'session-2', pin: { isLocalPin: false } },
+    ]);
+    const update = watchPinsUpdated(state);
+    update({ pins: [{ userId: 'u1', sessionId: 'session-1' }] });
+    expect(state.participants).toEqual([
+      {
+        userId: 'u1',
+        sessionId: 'session-1',
+        pin: { isLocalPin: false, pinnedAt: expect.any(Number) },
+      },
+      { userId: 'u2', sessionId: 'session-2', pin: undefined },
+    ]);
+  });
+});

package/src/events/__tests__/mutes.test.ts

@@ -20,12 +20,9 @@ describe('mutes', () => {
         id: 'test',
         streamClient: new StreamClient('api-key'),
       });
-      // disable all event handlers
-      call['dispatcher'].offAll();
 
       // @ts-expect-error partial data
       call.publisher = vi.fn();
-      // @ts-expect-error partial data
       call.publisher.isPublishing = vi.fn().mockReturnValue(true);
 
       vi.spyOn(call.camera, 'disable').mockResolvedValue(undefined);

package/src/events/__tests__/speaker.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import { CallState } from '../../store';
+import { noopComparator } from '../../sorting';
+import {
+  watchAudioLevelChanged,
+  watchDominantSpeakerChanged,
+} from '../speaker';
+import { Dispatcher } from '../../rtc';
+
+describe('speaker events', () => {
+  it('should watch dominant speaker changed', () => {
+    const state = new CallState();
+    state.setSortParticipantsBy(noopComparator());
+    state.setParticipants([
+      // @ts-expect-error
+      { userId: 'user-1', sessionId: 'session-1', isDominantSpeaker: false },
+      // @ts-expect-error
+      { userId: 'user-2', sessionId: 'session-2', isDominantSpeaker: true },
+    ]);
+    const dispatcher = new Dispatcher();
+
+    watchDominantSpeakerChanged(dispatcher, state);
+
+    dispatcher.dispatch({
+      eventPayload: {
+        oneofKind: 'dominantSpeakerChanged',
+        // @ts-expect-error
+        dominantSpeakerChanged: {
+          userId: 'user-1',
+          sessionId: 'session-1',
+        },
+      },
+    });
+
+    expect(state.participants).toEqual([
+      { userId: 'user-1', sessionId: 'session-1', isDominantSpeaker: true },
+      { userId: 'user-2', sessionId: 'session-2', isDominantSpeaker: false },
+    ]);
+  });
+
+  it('watchAudioLevelChanged', () => {
+    const state = new CallState();
+    state.setSortParticipantsBy(noopComparator());
+    state.setParticipants([
+      // @ts-expect-error
+      {
+        userId: 'user-1',
+        sessionId: 'session-1',
+        audioLevel: 0,
+        isSpeaking: false,
+      },
+      // @ts-expect-error
+      {
+        userId: 'user-2',
+        sessionId: 'session-2',
+        audioLevel: 0,
+        isSpeaking: false,
+      },
+    ]);
+    const dispatcher = new Dispatcher();
+
+    watchAudioLevelChanged(dispatcher, state);
+
+    dispatcher.dispatch({
+      eventPayload: {
+        oneofKind: 'audioLevelChanged',
+        // @ts-expect-error
+        audioLevelChanged: {
+          audioLevels: [
+            { sessionId: 'session-1', level: 0.5, isSpeaking: true },
+            { sessionId: 'session-2', level: 0.5, isSpeaking: true },
+          ],
+        },
+      },
+    });
+
+    expect(state.participants).toEqual([
+      {
+        userId: 'user-1',
+        sessionId: 'session-1',
+        audioLevel: 0.5,
+        isSpeaking: true,
+      },
+      {
+        userId: 'user-2',
+        sessionId: 'session-2',
+        audioLevel: 0.5,
+        isSpeaking: true,
+      },
+    ]);
+  });
+});

package/src/events/participant.ts

@@ -12,7 +12,8 @@ import {
   VisibilityState,
 } from '../types';
 import { CallState } from '../store';
-import { trackTypeToParticipantStreamKey } from '../rtc/helpers/tracks';
+import { trackTypeToParticipantStreamKey } from '../rtc';
+import { pushToIfMissing } from '../helpers/array';
 
 /**
  * An event responder which handles the `participantJoined` event.
@@ -88,7 +89,7 @@ export const watchTrackPublished = (state: CallState) => {
       state.updateOrAddParticipant(sessionId, participant);
     } else {
       state.updateParticipant(sessionId, (p) => ({
-        publishedTracks: [...p.publishedTracks, type].filter(unique),
+        publishedTracks: pushToIfMissing([...p.publishedTracks], type),
       }));
     }
   };
@@ -114,8 +115,6 @@ export const watchTrackUnpublished = (state: CallState) => {
   };
 };
 
-const unique = <T>(v: T, i: number, arr: T[]) => arr.indexOf(v) === i;
-
 /**
  * Reconciles orphaned tracks (if any) for the given participant.
  *