@stream-io/video-client 1.56.0 → 1.58.0

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

@@ -1,5 +1,5 @@
 import '../../rtc/__tests__/mocks/webrtc.mocks';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { CallState } from '../../store';
 import { VisibilityState } from '../../types';
 import { TrackType } from '../../gen/video/sfu/models/models';
@@ -192,6 +192,139 @@ describe('Participant events', () => {
       expect(p?.screenShareStream).toBe(mediaStream);
       expect(state.takeOrphanedTracks('track-lookup-prefix')).toHaveLength(0);
     });
+
+    it('participantJoined should attach E2EE decryptor to orphaned track receiver', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      const receiver = {} as RTCRtpReceiver;
+      const e2ee = { decrypt: vi.fn() };
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.VIDEO,
+        track: mediaStream,
+        id: mediaStream.id,
+        receiver,
+      });
+      // @ts-expect-error partial mock
+      const onParticipantJoined = watchParticipantJoined(state, () => e2ee);
+      onParticipantJoined({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      expect(e2ee.decrypt).toHaveBeenCalledWith(receiver, 'user-id', 'VIDEO');
+    });
+
+    it('trackPublished should attach E2EE decryptor to orphaned track receiver', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      const receiver = {} as RTCRtpReceiver;
+      const e2ee = { decrypt: vi.fn() };
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.AUDIO,
+        track: mediaStream,
+        id: mediaStream.id,
+        receiver,
+      });
+      // @ts-expect-error partial mock
+      const onTrackPublished = watchTrackPublished(state, () => e2ee);
+      onTrackPublished({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      expect(e2ee.decrypt).toHaveBeenCalledWith(receiver, 'user-id', 'AUDIO');
+    });
+
+    it('trackUnpublished should attach E2EE decryptor to orphaned track receiver', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      const receiver = {} as RTCRtpReceiver;
+      const e2ee = { decrypt: vi.fn() };
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.SCREEN_SHARE,
+        track: mediaStream,
+        id: mediaStream.id,
+        receiver,
+      });
+      // @ts-expect-error partial mock
+      const onTrackUnPublished = watchTrackUnpublished(state, () => e2ee);
+      onTrackUnPublished({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      expect(e2ee.decrypt).toHaveBeenCalledWith(
+        receiver,
+        'user-id',
+        'SCREEN_SHARE',
+      );
+    });
+
+    it('should not call decrypt when no E2EE manager is provided', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      const receiver = {} as RTCRtpReceiver;
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.VIDEO,
+        track: mediaStream,
+        id: mediaStream.id,
+        receiver,
+      });
+      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?.videoStream).toBe(mediaStream);
+    });
+
+    it('should not call decrypt when orphaned track has no receiver', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      const e2ee = { decrypt: vi.fn() };
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.VIDEO,
+        track: mediaStream,
+        id: mediaStream.id,
+      });
+      // @ts-expect-error partial mock
+      const onParticipantJoined = watchParticipantJoined(state, () => e2ee);
+      onParticipantJoined({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      expect(e2ee.decrypt).not.toHaveBeenCalled();
+      const p = state.findParticipantBySessionId('session-id');
+      expect(p?.videoStream).toBe(mediaStream);
+    });
   });
 
   describe('trackPublished', () => {

package/src/events/callEventHandlers.ts

@@ -40,6 +40,12 @@ type RingCallEvents = Extract<
  */
 export const registerEventHandlers = (call: Call, dispatcher: Dispatcher) => {
   const state = call.state;
+  // Read lazily on each event: setE2EEManager can run after setup() (an app that
+  // inspects call settings via get()/getOrCreate() before deciding to encrypt has
+  // already triggered it), so a value captured here would be a stale undefined
+  // for the whole call and orphaned tracks would never get a decryptor.
+  const e2ee = () => call.e2eeManager;
+
   const eventHandlers = [
     call.on('call.ended', watchCallEnded(call)),
     watchSfuCallEnded(call),
@@ -49,12 +55,12 @@ export const registerEventHandlers = (call: Call, dispatcher: Dispatcher) => {
     watchConnectionQualityChanged(dispatcher, state),
     watchParticipantCountChanged(dispatcher, state),
 
-    call.on('participantJoined', watchParticipantJoined(state)),
+    call.on('participantJoined', watchParticipantJoined(state, e2ee)),
     call.on('participantLeft', watchParticipantLeft(state)),
     call.on('participantUpdated', watchParticipantUpdated(state)),
 
-    call.on('trackPublished', watchTrackPublished(state)),
-    call.on('trackUnpublished', watchTrackUnpublished(state)),
+    call.on('trackPublished', watchTrackPublished(state, e2ee)),
+    call.on('trackUnpublished', watchTrackUnpublished(state, e2ee)),
 
     watchAudioLevelChanged(dispatcher, state),
     watchDominantSpeakerChanged(dispatcher, state),

package/src/events/participant.ts

@@ -5,7 +5,7 @@ import type {
   TrackPublished,
   TrackUnpublished,
 } from '../gen/video/sfu/event/events';
-import type { Participant } from '../gen/video/sfu/models/models';
+import { type Participant, TrackType } from '../gen/video/sfu/models/models';
 import {
   StreamVideoParticipant,
   StreamVideoParticipantPatch,
@@ -14,11 +14,21 @@ import {
 import { CallState } from '../store';
 import { trackTypeToParticipantStreamKey } from '../rtc';
 import { pushToIfMissing } from '../helpers/array';
+import type { E2EEManager } from '../rtc/e2ee/E2EEManager';
+
+/**
+ * Reads the call's current encryption manager. Deliberately not the manager
+ * itself: `Call.setE2EEManager` may be called after these handlers are wired up.
+ */
+type GetE2EEManager = () => E2EEManager | undefined;
 
 /**
  * An event responder which handles the `participantJoined` event.
  */
-export const watchParticipantJoined = (state: CallState) => {
+export const watchParticipantJoined = (
+  state: CallState,
+  e2ee: GetE2EEManager | undefined = undefined,
+) => {
   return function onParticipantJoined(e: ParticipantJoined) {
     const { participant } = e;
     if (!participant) return;
@@ -30,7 +40,7 @@ export const watchParticipantJoined = (state: CallState) => {
     // 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);
+    const orphanedTracks = reconcileOrphanedTracks(state, participant, e2ee);
     state.updateOrAddParticipant(
       participant.sessionId,
       Object.assign<
@@ -77,7 +87,10 @@ export const watchParticipantUpdated = (state: CallState) => {
  * An event responder which handles the `trackPublished` event.
  * The SFU will send this event when a participant publishes a track.
  */
-export const watchTrackPublished = (state: CallState) => {
+export const watchTrackPublished = (
+  state: CallState,
+  e2ee: GetE2EEManager | undefined = undefined,
+) => {
   return function onTrackPublished(e: TrackPublished) {
     const { type, sessionId } = e;
     // An optimization for large calls.
@@ -85,7 +98,11 @@ export const watchTrackPublished = (state: CallState) => {
     // events, and instead, it would only provide the participant's information
     // once they start publishing a track.
     if (e.participant) {
-      const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+      const orphanedTracks = reconcileOrphanedTracks(
+        state,
+        e.participant,
+        e2ee,
+      );
       const participant = Object.assign(e.participant, orphanedTracks);
       state.updateOrAddParticipant(sessionId, participant);
     } else {
@@ -100,12 +117,19 @@ export const watchTrackPublished = (state: CallState) => {
  * An event responder which handles the `trackUnpublished` event.
  * The SFU will send this event when a participant unpublishes a track.
  */
-export const watchTrackUnpublished = (state: CallState) => {
+export const watchTrackUnpublished = (
+  state: CallState,
+  e2ee: GetE2EEManager | undefined = undefined,
+) => {
   return function onTrackUnpublished(e: TrackUnpublished) {
     const { type, sessionId } = e;
     // An optimization for large calls. See `watchTrackPublished`.
     if (e.participant) {
-      const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+      const orphanedTracks = reconcileOrphanedTracks(
+        state,
+        e.participant,
+        e2ee,
+      );
       const participant = Object.assign(e.participant, orphanedTracks);
       state.updateOrAddParticipant(sessionId, participant, (p) => ({
         pausedTracks: p.pausedTracks?.filter((t) => t !== type),
@@ -124,18 +148,29 @@ export const watchTrackUnpublished = (state: CallState) => {
  *
  * @param state the call state.
  * @param participant the participant.
+ * @param e2ee accessor for the call's encryption manager, if any.
  */
 const reconcileOrphanedTracks = (
   state: CallState,
   participant: Participant,
+  e2ee: GetE2EEManager | undefined,
 ): StreamVideoParticipantPatch | undefined => {
   const orphanTracks = state.takeOrphanedTracks(participant.trackLookupPrefix);
   if (!orphanTracks.length) return;
+  const manager = e2ee?.();
   const reconciledTracks: StreamVideoParticipantPatch = {};
   for (const orphan of orphanTracks) {
     const key = trackTypeToParticipantStreamKey(orphan.trackType);
     if (!key) continue;
     reconciledTracks[key] = orphan.track;
+
+    if (manager && orphan.receiver) {
+      manager.decrypt(
+        orphan.receiver,
+        participant.userId,
+        TrackType[orphan.trackType],
+      );
+    }
   }
   return reconciledTracks;
 };