@stream-io/video-client 1.4.8 → 1.5.0-0

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

@@ -28,9 +28,9 @@ describe('mutes', () => {
       // @ts-expect-error partial data
       call.publisher.isPublishing = vi.fn().mockReturnValue(true);
 
-      vi.spyOn(call, 'stopPublish').mockResolvedValue(undefined);
       vi.spyOn(call.camera, 'disable').mockResolvedValue(undefined);
       vi.spyOn(call.microphone, 'disable').mockResolvedValue(undefined);
+      vi.spyOn(call.screenShare, 'disable').mockResolvedValue(undefined);
 
       // @ts-ignore
       call.on = (event: string, h) => {
@@ -56,41 +56,38 @@ describe('mutes', () => {
       });
     });
 
-    it('should automatically mute only when cause is moderation', async () => {
-      await handler!({
+    it('should automatically mute only when cause is moderation', () => {
+      handler!({
         cause: TrackUnpublishReason.PERMISSION_REVOKED,
         type: TrackType.VIDEO,
         sessionId: 'session-id',
         userId: 'user-id',
       });
       expect(call.camera.disable).not.toHaveBeenCalled();
-      expect(call.stopPublish).not.toHaveBeenCalledWith(TrackType.VIDEO);
     });
 
-    it('should handle remote soft video mute', async () => {
-      await handler!({
+    it('should handle remote soft video mute', () => {
+      handler!({
         cause: TrackUnpublishReason.MODERATION,
         type: TrackType.VIDEO,
         sessionId: 'session-id',
         userId: 'user-id',
       });
       expect(call.camera.disable).toHaveBeenCalled();
-      expect(call.stopPublish).toHaveBeenCalledWith(TrackType.VIDEO);
     });
 
-    it('should handle remote soft audio mute', async () => {
-      await handler!({
+    it('should handle remote soft audio mute', () => {
+      handler!({
         cause: TrackUnpublishReason.MODERATION,
         type: TrackType.AUDIO,
         sessionId: 'session-id',
         userId: 'user-id',
       });
       expect(call.microphone.disable).toHaveBeenCalled();
-      expect(call.stopPublish).toHaveBeenCalledWith(TrackType.AUDIO);
     });
 
-    it('should handle remote soft screenshare mute', async () => {
-      await handler!({
+    it('should handle remote soft screenshare mute', () => {
+      handler!({
         cause: TrackUnpublishReason.MODERATION,
         type: TrackType.SCREEN_SHARE,
         sessionId: 'session-id',
@@ -98,7 +95,7 @@ describe('mutes', () => {
       });
       expect(call.camera.disable).not.toHaveBeenCalled();
       expect(call.microphone.disable).not.toHaveBeenCalled();
-      expect(call.stopPublish).toHaveBeenCalledWith(TrackType.SCREEN_SHARE);
+      expect(call.screenShare.disable).toHaveBeenCalled();
     });
   });
 });

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

@@ -1,3 +1,4 @@
+import '../../rtc/__tests__/mocks/webrtc.mocks';
 import { describe, expect, it } from 'vitest';
 import { CallState } from '../../store';
 import { VisibilityState } from '../../types';
@@ -75,6 +76,80 @@ describe('Participant events', () => {
     });
   });
 
+  describe('orphaned tracks reconciliation', () => {
+    it('participantJoined should reconcile orphaned tracks if any', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.VIDEO,
+        track: mediaStream,
+      });
+      const onParticipantJoined = watchParticipantJoined(state);
+      onParticipantJoined({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      const p = state.findParticipantBySessionId('session-id');
+      expect(p).toBeDefined();
+      expect(p?.videoStream).toBe(mediaStream);
+      expect(state.takeOrphanedTracks('track-lookup-prefix')).toHaveLength(0);
+    });
+
+    it('trackPublished should reconcile orphaned tracks if any', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.AUDIO,
+        track: mediaStream,
+      });
+      const onTrackPublished = watchTrackPublished(state);
+      onTrackPublished({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      const p = state.findParticipantBySessionId('session-id');
+      expect(p).toBeDefined();
+      expect(p?.audioStream).toBe(mediaStream);
+      expect(state.takeOrphanedTracks('track-lookup-prefix')).toHaveLength(0);
+    });
+
+    it('trackUnpublished should reconcile orphaned tracks if any', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.SCREEN_SHARE,
+        track: mediaStream,
+      });
+      const onTrackUnPublished = watchTrackUnpublished(state);
+      onTrackUnPublished({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      const p = state.findParticipantBySessionId('session-id');
+      expect(p).toBeDefined();
+      expect(p?.screenShareStream).toBe(mediaStream);
+      expect(state.takeOrphanedTracks('track-lookup-prefix')).toHaveLength(0);
+    });
+  });
+
   describe('trackPublished', () => {
     it('updates the participant track list', () => {
       const state = new CallState();

package/src/events/callEventHandlers.ts

@@ -1,6 +1,5 @@
 import { Call } from '../Call';
 import { Dispatcher } from '../rtc';
-import { CallState } from '../store';
 import {
   handleRemoteSoftMute,
   watchAudioLevelChanged,
@@ -17,6 +16,7 @@ import {
   watchParticipantLeft,
   watchParticipantUpdated,
   watchPinsUpdated,
+  watchSfuCallEnded,
   watchSfuErrorReports,
   watchTrackPublished,
   watchTrackUnpublished,
@@ -36,16 +36,13 @@ type RingCallEvents = Extract<
  * Registers the default event handlers for a call during its lifecycle.
  *
  * @param call the call to register event handlers for.
- * @param state the call state.
  * @param dispatcher the dispatcher.
  */
-export const registerEventHandlers = (
-  call: Call,
-  state: CallState,
-  dispatcher: Dispatcher,
-) => {
+export const registerEventHandlers = (call: Call, dispatcher: Dispatcher) => {
+  const state = call.state;
   const eventHandlers = [
     call.on('call.ended', watchCallEnded(call)),
+    watchSfuCallEnded(call),
 
     watchLiveEnded(dispatcher, call),
     watchSfuErrorReports(dispatcher),

package/src/events/internal.ts

@@ -3,8 +3,12 @@ import { Call } from '../Call';
 import { CallState } from '../store';
 import { StreamVideoParticipantPatches } from '../types';
 import { getLogger } from '../logger';
-import type { PinsChanged } from '../gen/video/sfu/event/events';
-import { ErrorCode } from '../gen/video/sfu/models/models';
+import type { CallEnded, PinsChanged } from '../gen/video/sfu/event/events';
+import {
+  CallEndedReason,
+  ErrorCode,
+  WebsocketReconnectStrategy,
+} from '../gen/video/sfu/models/models';
 import { OwnCapability } from '../gen/coordinator';
 
 const logger = getLogger(['events']);
@@ -82,9 +86,10 @@ export const watchLiveEnded = (dispatcher: Dispatcher, call: Call) => {
 export const watchSfuErrorReports = (dispatcher: Dispatcher) => {
   return dispatcher.on('error', (e) => {
     if (!e.error) return;
-    const { error } = e;
+    const { error, reconnectStrategy } = e;
     logger('error', 'SFU reported error', {
       code: ErrorCode[error.code],
+      reconnectStrategy: WebsocketReconnectStrategy[reconnectStrategy],
       message: error.message,
       shouldRetry: error.shouldRetry,
     });
@@ -101,3 +106,15 @@ export const watchPinsUpdated = (state: CallState) => {
     state.setServerSidePins(pins);
   };
 };
+
+/**
+ * Watches for `callEnded` events.
+ */
+export const watchSfuCallEnded = (call: Call) => {
+  return call.on('callEnded', (e: CallEnded) => {
+    const reason = CallEndedReason[e.reason];
+    call.leave({ reason }).catch((err) => {
+      logger('error', 'Failed to leave call after call ended by the SFU', err);
+    });
+  });
+};

package/src/events/mutes.ts

@@ -27,6 +27,11 @@ export const handleRemoteSoftMute = (call: Call) => {
           await call.camera.disable();
         } else if (type === TrackType.AUDIO) {
           await call.microphone.disable();
+        } else if (
+          type === TrackType.SCREEN_SHARE ||
+          type === TrackType.SCREEN_SHARE_AUDIO
+        ) {
+          await call.screenShare.disable();
         } else {
           logger(
             'warn',
@@ -34,9 +39,6 @@ export const handleRemoteSoftMute = (call: Call) => {
             TrackType[type],
           );
         }
-        if (call.publisher?.isPublishing(type)) {
-          await call.stopPublish(type);
-        }
       } catch (error) {
         logger('error', 'Failed to stop publishing', error);
       }

package/src/events/participant.ts

@@ -5,8 +5,14 @@ import type {
   TrackPublished,
   TrackUnpublished,
 } from '../gen/video/sfu/event/events';
-import { StreamVideoParticipant, VisibilityState } from '../types';
+import type { Participant } from '../gen/video/sfu/models/models';
+import {
+  StreamVideoParticipant,
+  StreamVideoParticipantPatch,
+  VisibilityState,
+} from '../types';
 import { CallState } from '../store';
+import { trackTypeToParticipantStreamKey } from '../rtc/helpers/tracks';
 
 /**
  * An event responder which handles the `participantJoined` event.
@@ -19,21 +25,23 @@ export const watchParticipantJoined = (state: CallState) => {
     // potential duplicate events from the SFU.
     //
     // Although the SFU should not send duplicate events, we have seen
-    // some race conditions in the past during the `join-flow` where
-    // the SFU would send participant info as part of the `join`
+    // some race conditions in the past during the `join-flow`.
+    // The SFU would send participant info as part of the `join`
     // response and then follow up with a `participantJoined` event for
     // already announced participants.
+    const orphanedTracks = reconcileOrphanedTracks(state, participant);
     state.updateOrAddParticipant(
       participant.sessionId,
-      Object.assign<StreamVideoParticipant, Partial<StreamVideoParticipant>>(
-        participant,
-        {
-          viewportVisibilityState: {
-            videoTrack: VisibilityState.UNKNOWN,
-            screenShareTrack: VisibilityState.UNKNOWN,
-          },
+      Object.assign<
+        StreamVideoParticipant,
+        StreamVideoParticipantPatch | undefined,
+        Partial<StreamVideoParticipant>
+      >(participant, orphanedTracks, {
+        viewportVisibilityState: {
+          videoTrack: VisibilityState.UNKNOWN,
+          screenShareTrack: VisibilityState.UNKNOWN,
         },
-      ),
+      }),
     );
   };
 };
@@ -69,12 +77,14 @@ export const watchParticipantUpdated = (state: CallState) => {
  */
 export const watchTrackPublished = (state: CallState) => {
   return function onTrackPublished(e: TrackPublished) {
-    const { type, sessionId, participant } = e;
+    const { type, sessionId } = e;
     // An optimization for large calls.
     // After a certain threshold, the SFU would stop emitting `participantJoined`
     // events, and instead, it would only provide the participant's information
     // once they start publishing a track.
-    if (participant) {
+    if (e.participant) {
+      const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+      const participant = Object.assign(e.participant, orphanedTracks);
       state.updateOrAddParticipant(sessionId, participant);
     } else {
       state.updateParticipant(sessionId, (p) => ({
@@ -90,9 +100,11 @@ export const watchTrackPublished = (state: CallState) => {
  */
 export const watchTrackUnpublished = (state: CallState) => {
   return function onTrackUnpublished(e: TrackUnpublished) {
-    const { type, sessionId, participant } = e;
+    const { type, sessionId } = e;
     // An optimization for large calls. See `watchTrackPublished`.
-    if (participant) {
+    if (e.participant) {
+      const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+      const participant = Object.assign(e.participant, orphanedTracks);
       state.updateOrAddParticipant(sessionId, participant);
     } else {
       state.updateParticipant(sessionId, (p) => ({
@@ -103,3 +115,24 @@ 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.
+ *
+ * @param state the call state.
+ * @param participant the participant.
+ */
+const reconcileOrphanedTracks = (
+  state: CallState,
+  participant: Participant,
+): StreamVideoParticipantPatch | undefined => {
+  const orphanTracks = state.takeOrphanedTracks(participant.trackLookupPrefix);
+  if (!orphanTracks.length) return;
+  const reconciledTracks: StreamVideoParticipantPatch = {};
+  for (const orphan of orphanTracks) {
+    const key = trackTypeToParticipantStreamKey(orphan.trackType);
+    if (!key) continue;
+    reconciledTracks[key] = orphan.track;
+  }
+  return reconciledTracks;
+};