@stream-io/video-client 1.57.0 → 1.58.0

package/src/rtc/e2ee/transformSupport.ts

@@ -0,0 +1,35 @@
+import { isChrome } from '../../helpers/browsers';
+
+/**
+ * Detection and selection policy for the two WebRTC Encoded Transform APIs.
+ * Internal: which one the SDK attaches is an RTC-layer detail. Consumers want
+ * `EncryptionManager.isSupported` instead.
+ */
+
+/**
+ * Chrome only, and the reason an RTCPeerConnection carrying E2EE needs the
+ * non-standard `encodedInsertableStreams` flag.
+ */
+export const hasInsertableStreams = (): boolean =>
+  typeof RTCRtpSender !== 'undefined' &&
+  'createEncodedStreams' in RTCRtpSender.prototype;
+
+/** Whether the standard `RTCRtpScriptTransform` API exists. */
+export const hasScriptTransform = (): boolean =>
+  typeof RTCRtpScriptTransform !== 'undefined';
+
+/**
+ * Which Encoded Transform API to attach E2EE with here.
+ *
+ * - `'insertable'`: legacy Insertable Streams. Used on Chrome, where
+ *   `RTCRtpScriptTransform` is still unreliable for E2EE.
+ * - `'script'`: the standard API. Used everywhere else.
+ * - `undefined`: neither exists, so E2EE cannot run.
+ */
+export const preferredTransform = (): 'script' | 'insertable' | undefined => {
+  const insertable = hasInsertableStreams();
+  // Chrome's RTCRtpScriptTransform is still unreliable for E2EE.
+  if (isChrome() && insertable) return 'insertable';
+  if (hasScriptTransform()) return 'script';
+  return insertable ? 'insertable' : undefined;
+};

package/src/rtc/helpers/rtcConfiguration.ts

@@ -1,6 +1,8 @@
-import { ICEServer } from '../../gen/coordinator';
+import { ICEServerResponse } from '../../gen/coordinator';
 
-export const toRtcConfiguration = (config: ICEServer[]): RTCConfiguration => {
+export const toRtcConfiguration = (
+  config: ICEServerResponse[],
+): RTCConfiguration => {
   return {
     bundlePolicy: 'max-bundle',
     iceServers: config.map((ice) => ({

package/src/rtc/index.ts

@@ -1,4 +1,5 @@
 export * from './codecs';
+export * from './mediaEngine';
 export * from './Dispatcher';
 export * from './NegotiationError';
 export * from './IceTrickleBuffer';

package/src/rtc/mediaEngine.ts

@@ -0,0 +1,44 @@
+/**
+ * A per-call media engine. On React Native it owns the call's native
+ * `PeerConnectionFactory` (built with the call's audio configuration); on web it
+ * is a no-op. Capture (`getUserMedia`/`getDisplayMedia`) and peer-connection creation
+ * always go through the WebRTC globals, which resolve to this factory while it
+ * is the live call factory — so the engine only needs to manage its lifecycle.
+ *
+ * @internal
+ */
+export interface CallMediaEngine {
+  dispose(): Promise<boolean>;
+}
+
+/**
+ * Creates a per-call {@link CallMediaEngine}. Registered once at SDK startup
+ * via {@link setCallMediaEngineProvider}. May return the engine synchronously
+ * (the default globals engine) or asynchronously (React Native, where allocating
+ * the native per-call factory is an async bridge call).
+ *
+ * @internal
+ */
+export type CallMediaEngineProvider = () =>
+  CallMediaEngine | Promise<CallMediaEngine>;
+
+/**
+ * The default engine: a thin, stateless wrapper over the WebRTC globals.
+ */
+const defaultGlobalsEngine: CallMediaEngine = {
+  dispose: () => Promise.resolve(true),
+};
+
+const defaultGlobalsEngineProvider: CallMediaEngineProvider = () =>
+  defaultGlobalsEngine;
+
+let provider: CallMediaEngineProvider = defaultGlobalsEngineProvider;
+
+export const setCallMediaEngineProvider = (
+  newProvider: CallMediaEngineProvider,
+): void => {
+  provider = newProvider;
+};
+
+export const getCallMediaEngineProvider = (): CallMediaEngineProvider =>
+  provider;

package/src/rtc/types.ts

@@ -10,6 +10,7 @@ import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
 import type { ClientPublishOptions } from '../types';
+import type { E2EEManager } from './e2ee/E2EEManager';
 import type { VideoSender } from '../gen/video/sfu/event/events';
 
 /**
@@ -102,6 +103,7 @@ export type BasePeerConnectionOpts = {
   iceRestartDelay?: number;
   clientPublishOptions?: ClientPublishOptions;
   statsTimestampDriftThresholdMs?: number;
+  e2ee?: E2EEManager;
 };
 
 export type TrackPublishOptions = {

package/src/store/CallState.ts

@@ -74,6 +74,7 @@ type OrphanedTrack = {
   trackLookupPrefix: string;
   trackType: TrackType;
   track: MediaStream;
+  receiver?: RTCRtpReceiver;
 };
 
 /**
@@ -108,6 +109,7 @@ export class CallState {
   >(undefined);
   private transcribingSubject = new BehaviorSubject<boolean>(false);
   private captioningSubject = new BehaviorSubject<boolean>(false);
+  private e2eeEnabledSubject = new BehaviorSubject<boolean>(false);
   private endedBySubject = new BehaviorSubject<UserResponse | undefined>(
     undefined,
   );
@@ -311,6 +313,12 @@ export class CallState {
    */
   captioning$: Observable<boolean>;
 
+  /**
+   * Whether end-to-end encryption is active for this call, as reported by the
+   * SFU in the join response.
+   */
+  e2eeEnabled$: Observable<boolean>;
+
   /**
    * Will provide the user who ended this call.
    */
@@ -467,6 +475,7 @@ export class CallState {
     this.rawRecording$ = duc(this.rawRecordingSubject);
     this.transcribing$ = duc(this.transcribingSubject);
     this.captioning$ = duc(this.captioningSubject);
+    this.e2eeEnabled$ = duc(this.e2eeEnabledSubject);
 
     this.eventHandlers = {
       // these events are not updating the call state:
@@ -574,6 +583,7 @@ export class CallState {
       clearTimeout(taskId);
       this.closedCaptionsTasks.delete(ccKey);
     }
+    this.removeAllOrphanedTracks();
   };
 
   /**
@@ -973,6 +983,13 @@ export class CallState {
     return this.getCurrentValue(this.transcribing$);
   }
 
+  /**
+   * Whether end-to-end encryption is active for this call.
+   */
+  get e2eeEnabled() {
+    return this.getCurrentValue(this.e2eeEnabled$);
+  }
+
   /**
    * Will provide the user who ended this call.
    */
@@ -1249,6 +1266,19 @@ export class CallState {
     this.orphanedTracks = this.orphanedTracks.filter((o) => o.id !== id);
   };
 
+  /**
+   * Drops every orphaned track. Call this when the peer connections that own
+   * the stored receivers go away (full leave, reconnect, or migration):
+   * `pc.close()` does not raise the track `ended` event, so the per-track
+   * cleanup never fires and the receivers + their closed PCs would otherwise
+   * leak for the call's lifetime.
+   *
+   * @internal
+   */
+  removeAllOrphanedTracks = () => {
+    this.orphanedTracks = [];
+  };
+
   /**
    * Takes all orphaned tracks with the given track lookup prefix.
    * All orphaned tracks with the given track lookup prefix are removed from the call state.
@@ -1336,7 +1366,8 @@ export class CallState {
     currentSessionId: string,
     reconnectDetails?: ReconnectDetails,
   ) => {
-    const { participants, participantCount, startedAt, pins } = callState;
+    const { participants, participantCount, startedAt, pins, e2EeEnabled } =
+      callState;
     const localPublishedTracks =
       reconnectDetails?.announcedTracks.map((t) => t.trackType) ?? [];
     this.setParticipants(() => {
@@ -1365,6 +1396,7 @@ export class CallState {
     this.setAnonymousParticipantCount(participantCount?.anonymous || 0);
     this.setStartedAt(startedAt ? Timestamp.toDate(startedAt) : new Date());
     this.setServerSidePins(pins);
+    this.setCurrentValue(this.e2eeEnabledSubject, e2EeEnabled);
   };
 
   private updateFromMemberRemoved = (event: CallMemberRemovedEvent) => {

package/src/store/__tests__/CallState.test.ts

@@ -5,7 +5,10 @@ import { fromPartial } from '@total-typescript/shoehorn';
 import { StreamVideoParticipant, VisibilityState } from '../../types';
 import { CallingState } from '../CallingState';
 import { CallState } from '../CallState';
-import { TrackType } from '../../gen/video/sfu/models/models';
+import {
+  type CallState as SfuCallState,
+  TrackType,
+} from '../../gen/video/sfu/models/models';
 import {
   combineComparators,
   conditional,
@@ -387,6 +390,48 @@ describe('CallState', () => {
     });
   });
 
+  describe('e2ee', () => {
+    const sfuCallState = (e2EeEnabled: boolean) =>
+      fromPartial<SfuCallState>({
+        participants: [],
+        pins: [],
+        e2EeEnabled,
+      });
+
+    it('is disabled until the SFU reports otherwise', () => {
+      const state = new CallState();
+      expect(state.e2eeEnabled).toBe(false);
+
+      state.updateFromSfuCallState(sfuCallState(false), 'session-id');
+      expect(state.e2eeEnabled).toBe(false);
+    });
+
+    it('is enabled when the SFU call state says so', () => {
+      const state = new CallState();
+      state.updateFromSfuCallState(sfuCallState(true), 'session-id');
+      expect(state.e2eeEnabled).toBe(true);
+    });
+
+    it('follows the SFU across a rejoin into a plain call', () => {
+      const state = new CallState();
+      state.updateFromSfuCallState(sfuCallState(true), 'session-id');
+      state.updateFromSfuCallState(sfuCallState(false), 'session-id');
+      expect(state.e2eeEnabled).toBe(false);
+    });
+
+    it(`doesn't emit when the value didn't change`, () => {
+      const state = new CallState();
+      const listener = vi.fn();
+      state.e2eeEnabled$.subscribe(listener);
+      expect(listener).toHaveBeenCalledTimes(1); // initial value
+
+      state.updateFromSfuCallState(sfuCallState(true), 'session-id');
+      state.updateFromSfuCallState(sfuCallState(true), 'session-id');
+      expect(listener).toHaveBeenCalledTimes(2);
+      expect(listener).toHaveBeenLastCalledWith(true);
+    });
+  });
+
   describe('events', () => {
     describe('call.live and backstage events', () => {
       it('handles call.live_started events', () => {
@@ -1291,6 +1336,42 @@ describe('CallState', () => {
       state.removeOrphanedTrack(id);
       expect(state['orphanedTracks'].length).toBe(0);
     });
+
+    it('removes all orphaned tracks at once', () => {
+      const state = new CallState();
+      state.registerOrphanedTrack({
+        id: 'a',
+        track: new MediaStream(),
+        trackLookupPrefix: '1',
+        trackType: TrackType.VIDEO,
+      });
+      state.registerOrphanedTrack({
+        id: 'b',
+        track: new MediaStream(),
+        trackLookupPrefix: '2',
+        trackType: TrackType.AUDIO,
+      });
+      expect(state['orphanedTracks'].length).toBe(2);
+      state.removeAllOrphanedTracks();
+      expect(state['orphanedTracks'].length).toBe(0);
+    });
+
+    it('purges orphaned tracks on dispose (no receiver/PC leak)', () => {
+      // Orphaned tracks can hold an RTCRtpReceiver tied to a now-closed peer
+      // connection; pc.close() does not raise the track `ended` event, so they
+      // are never purged otherwise and leak for the call's lifetime (finding
+      // 15).
+      const state = new CallState();
+      state.registerOrphanedTrack({
+        id: '123:TRACK_TYPE_VIDEO',
+        track: new MediaStream(),
+        trackLookupPrefix: '123',
+        trackType: TrackType.VIDEO,
+      });
+      expect(state['orphanedTracks'].length).toBe(1);
+      state.dispose();
+      expect(state['orphanedTracks'].length).toBe(0);
+    });
   });
 
   describe('closed captions', () => {

package/src/types.ts

@@ -9,7 +9,7 @@ import type {
   JoinCallRequest,
   MemberResponse,
   OwnCapability,
-  ReactionResponse,
+  VideoReactionResponse,
   StartRecordingRequest,
   StartRecordingResponse,
 } from './gen/coordinator';
@@ -27,7 +27,7 @@ import { AxiosError } from 'axios';
 import type { Call } from './Call';
 
 export type StreamReaction = Pick<
-  ReactionResponse,
+  VideoReactionResponse,
   'type' | 'emoji_code' | 'custom'
 >;
 
@@ -421,9 +421,20 @@ type StreamRNVideoSDKCallManagerRingingParams = {
 
 type StreamRNVideoSDKCallManagerSetupParams =
   StreamRNVideoSDKCallManagerRingingParams & {
+    cid: string;
     defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
   };
 
+type StreamRNVideoSDKCallManagerStartParams =
+  StreamRNVideoSDKCallManagerRingingParams & {
+    cid: string;
+  };
+
+type StreamRNVideoSDKCallManagerStopParams =
+  StreamRNVideoSDKCallManagerRingingParams & {
+    shouldStopCallManager: boolean;
+  };
+
 type StreamRNVideoSDKEndCallReason =
   /** Call ended by the local user (e.g., hanging up). */
   | 'local'
@@ -453,6 +464,8 @@ type StreamRNVideoSDKCallingX = {
     reason?: StreamRNVideoSDKEndCallReason,
   ) => Promise<void>;
   registerOutgoingCall: (call: Call) => Promise<void>;
+  wireAudioEngineSubscription: () => void;
+  unwireAudioEngineSubscription: () => void;
 };
 
 export type StreamRNVideoSDKGlobals = {
@@ -464,6 +477,7 @@ export type StreamRNVideoSDKGlobals = {
     setup({
       defaultDevice,
       isRingingTypeCall,
+      cid,
     }: StreamRNVideoSDKCallManagerSetupParams): void;
 
     /**
@@ -471,12 +485,16 @@ export type StreamRNVideoSDKGlobals = {
      */
     start({
       isRingingTypeCall,
-    }: StreamRNVideoSDKCallManagerRingingParams): void;
+      cid,
+    }: StreamRNVideoSDKCallManagerStartParams): void;
 
     /**
      * Stops the in call manager.
      */
-    stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
+    stop({
+      isRingingTypeCall,
+      shouldStopCallManager,
+    }: StreamRNVideoSDKCallManagerStopParams): void;
 
     /**
      * iOS-only. Keeps the audio engine's microphone-input (voice-processing)
@@ -514,5 +532,5 @@ declare global {
 /**
  * The options to pass to {@link Call.join} method.
  */
-export type JoinCallData = Omit<JoinCallRequest, 'location'>;
+export type JoinCallData = Omit<JoinCallRequest, 'location' | 'e2ee'>;
 export { AxiosError };