@stream-io/video-client 0.3.2 → 0.3.4

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

@@ -7,6 +7,14 @@ import { mockCall, mockVideoDevices, mockVideoStream } from './mocks';
 import { InputMediaDeviceManager } from '../InputMediaDeviceManager';
 import { InputMediaDeviceManagerState } from '../InputMediaDeviceManagerState';
 import { of } from 'rxjs';
+import { disposeOfMediaStream } from '../devices';
+
+vi.mock('../devices.ts', () => {
+  console.log('MOCKING devices');
+  return {
+    disposeOfMediaStream: vi.fn(),
+  };
+});
 
 vi.mock('../../Call.ts', () => {
   console.log('MOCKING Call');
@@ -24,8 +32,8 @@ class TestInputMediaDeviceManager extends InputMediaDeviceManager<TestInputMedia
   public getStream = vi.fn(() => Promise.resolve(mockVideoStream()));
   public publishStream = vi.fn();
   public stopPublishStream = vi.fn();
-  public pause = vi.fn();
-  public resume = vi.fn();
+  public muteTracks = vi.fn();
+  public unmuteTracks = vi.fn();
 
   constructor(call: Call) {
     super(call, new TestInputMediaDeviceManagerState());
@@ -92,14 +100,14 @@ describe('InputMediaDeviceManager.test', () => {
     expect(manager.state.status).toBe('disabled');
   });
 
-  it('disable camera - after joined to call', async () => {
+  it('disable device - after joined to call', async () => {
     // @ts-expect-error
     manager['call'].state.callingState = CallingState.JOINED;
     await manager.enable();
 
     await manager.disable();
 
-    expect(manager.stopPublishStream).toHaveBeenCalledWith();
+    expect(manager.stopPublishStream).toHaveBeenCalledWith(true);
   });
 
   it('toggle device', async () => {
@@ -124,6 +132,16 @@ describe('InputMediaDeviceManager.test', () => {
     expect(manager.publishStream).not.toHaveBeenCalled();
   });
 
+  it('select device when status is enabled', async () => {
+    await manager.enable();
+    const prevStream = manager.state.mediaStream;
+
+    const deviceId = mockVideoDevices[1].deviceId;
+    await manager.select(deviceId);
+
+    expect(disposeOfMediaStream).toHaveBeenCalledWith(prevStream);
+  });
+
   it('select device when status is enabled and in call', async () => {
     // @ts-expect-error
     manager['call'].state.callingState = CallingState.JOINED;
@@ -132,7 +150,7 @@ describe('InputMediaDeviceManager.test', () => {
     const deviceId = mockVideoDevices[1].deviceId;
     await manager.select(deviceId);
 
-    expect(manager.stopPublishStream).toHaveBeenCalledWith();
+    expect(manager.stopPublishStream).toHaveBeenCalledWith(true);
     expect(manager.getStream).toHaveBeenCalledWith({
       deviceId,
     });
@@ -152,6 +170,31 @@ describe('InputMediaDeviceManager.test', () => {
     expect(spy.mock.calls.length).toBe(1);
   });
 
+  it('should resume previously enabled state', async () => {
+    vi.spyOn(manager, 'enable');
+
+    await manager.enable();
+
+    expect(manager.enable).toHaveBeenCalledTimes(1);
+
+    await manager.disable();
+    await manager.resume();
+
+    expect(manager.enable).toHaveBeenCalledTimes(2);
+  });
+
+  it(`shouldn't resume if previous state is disabled`, async () => {
+    vi.spyOn(manager, 'enable');
+
+    await manager.disable();
+
+    expect(manager.enable).not.toHaveBeenCalled();
+
+    await manager.resume();
+
+    expect(manager.enable).not.toHaveBeenCalled();
+  });
+
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();

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

@@ -81,19 +81,20 @@ describe('MicrophoneManager', () => {
 
     await manager.disable();
 
-    expect(manager['call'].stopPublish).toHaveBeenCalledWith(TrackType.AUDIO);
+    expect(manager['call'].stopPublish).toHaveBeenCalledWith(
+      TrackType.AUDIO,
+      false,
+    );
   });
 
-  it('should pause and resume tracks', async () => {
+  it('disable-enable mic should set track.enabled', async () => {
     await manager.enable();
 
-    manager.pause();
-
-    expect(manager.state.mediaStream?.getAudioTracks()[0].enabled).toBe(false);
+    expect(manager.state.mediaStream!.getAudioTracks()[0].enabled).toBe(true);
 
-    manager.resume();
+    await manager.disable();
 
-    expect(manager.state.mediaStream?.getAudioTracks()[0].enabled).toBe(true);
+    expect(manager.state.mediaStream!.getAudioTracks()[0].enabled).toBe(false);
   });
 
   afterEach(() => {

package/src/rtc/Publisher.ts

@@ -283,6 +283,9 @@ export class Publisher {
         previousTrack.removeEventListener('ended', handleTrackEnded);
         track.addEventListener('ended', handleTrackEnded);
       }
+      if (!track.enabled) {
+        track.enabled = true;
+      }
       await transceiver.sender.replaceTrack(track);
     }
 
@@ -298,8 +301,9 @@ export class Publisher {
    * Stops publishing the given track type to the SFU, if it is currently being published.
    * Underlying track will be stopped and removed from the publisher.
    * @param trackType the track type to unpublish.
+   * @param stopTrack specifies whether track should be stopped or just disabled
    */
-  unpublishStream = async (trackType: TrackType) => {
+  unpublishStream = async (trackType: TrackType, stopTrack: boolean) => {
     const transceiver = this.pc
       .getTransceivers()
       .find((t) => t === this.transceiverRegistry[trackType] && t.sender.track);
@@ -308,7 +312,9 @@ export class Publisher {
       transceiver.sender.track &&
       transceiver.sender.track.readyState === 'live'
     ) {
-      transceiver.sender.track.stop();
+      stopTrack
+        ? transceiver.sender.track.stop()
+        : (transceiver.sender.track.enabled = false);
       return this.notifyTrackMuteStateChanged(
         undefined,
         transceiver.sender.track,

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

@@ -139,7 +139,7 @@ describe('Publisher', () => {
     expect(state.localParticipant?.videoDeviceId).toEqual('test-device-id-2');
 
     // stop publishing
-    await publisher.unpublishStream(TrackType.VIDEO);
+    await publisher.unpublishStream(TrackType.VIDEO, true);
     expect(newTrack.stop).toHaveBeenCalled();
     expect(state.localParticipant?.publishedTracks).not.toContain(
       TrackType.VIDEO,
@@ -147,6 +147,72 @@ describe('Publisher', () => {
     expect(state.localParticipant?.videoDeviceId).toEqual('test-device-id-2');
   });
 
+  it('can publish and un-pubish with just enabling and disabling tracks', async () => {
+    const mediaStream = new MediaStream();
+    const track = new MediaStreamTrack();
+    mediaStream.addTrack(track);
+
+    state.setParticipants([
+      // @ts-ignore
+      {
+        isLocalParticipant: true,
+        userId: 'test-user-id',
+        sessionId: sessionId,
+        publishedTracks: [],
+      },
+    ]);
+
+    vi.spyOn(track, 'getSettings').mockReturnValue({
+      width: 640,
+      height: 480,
+      deviceId: 'test-device-id',
+    });
+
+    const transceiver = new RTCRtpTransceiver();
+    vi.spyOn(transceiver.sender, 'track', 'get').mockReturnValue(track);
+    vi.spyOn(publisher['pc'], 'addTransceiver').mockReturnValue(transceiver);
+    vi.spyOn(publisher['pc'], 'getTransceivers').mockReturnValue([transceiver]);
+
+    sfuClient.updateMuteState = vi.fn();
+
+    // initial publish
+    await publisher.publishStream(mediaStream, track, TrackType.VIDEO);
+
+    expect(state.localParticipant?.videoDeviceId).toEqual('test-device-id');
+    expect(state.localParticipant?.publishedTracks).toContain(TrackType.VIDEO);
+    expect(state.localParticipant?.videoStream).toEqual(mediaStream);
+    expect(transceiver.setCodecPreferences).toHaveBeenCalled();
+    expect(sfuClient.updateMuteState).toHaveBeenCalledWith(
+      TrackType.VIDEO,
+      false,
+    );
+
+    expect(track.addEventListener).toHaveBeenCalledWith(
+      'ended',
+      expect.any(Function),
+    );
+
+    // stop publishing
+    await publisher.unpublishStream(TrackType.VIDEO, false);
+    expect(track.stop).not.toHaveBeenCalled();
+    expect(track.enabled).toBe(false);
+    expect(state.localParticipant?.publishedTracks).not.toContain(
+      TrackType.VIDEO,
+    );
+    expect(state.localParticipant?.videoStream).toBeUndefined();
+
+    const addEventListenerSpy = vi.spyOn(track, 'addEventListener');
+    const removeEventListenerSpy = vi.spyOn(track, 'removeEventListener');
+
+    // start publish again
+    await publisher.publishStream(mediaStream, track, TrackType.VIDEO);
+
+    expect(track.enabled).toBe(true);
+    // republishing the same stream should use the previously registered event handlers
+    expect(removeEventListenerSpy).not.toHaveBeenCalled();
+    expect(addEventListenerSpy).not.toHaveBeenCalled();
+  });
+
   describe('Publisher migration', () => {
     it('should update the sfuClient and peer connection configuration', async () => {
       const newSfuClient = new StreamSfuClient({