@stream-io/video-client 1.56.0 → 1.58.0

package/src/gen/video/sfu/models/models.ts

@@ -40,6 +40,14 @@ export interface CallState {
    * @generated from protobuf field: repeated stream.video.sfu.models.Pin pins = 4;
    */
   pins: Pin[];
+  /**
+   * e2ee_enabled is true when the call uses end-to-end encryption. Clients
+   * must enable their frame encryptor; the SFU forwards encrypted frames
+   * opaquely and server-side recording/transcription/broadcasting are disabled.
+   *
+   * @generated from protobuf field: bool e2ee_enabled = 5 [json_name = "e2eeEnabled"];
+   */
+  e2EeEnabled: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.ParticipantCount
@@ -1401,6 +1409,13 @@ class CallState$Type extends MessageType<CallState> {
         repeat: 2 /*RepeatType.UNPACKED*/,
         T: () => Pin,
       },
+      {
+        no: 5,
+        name: 'e2ee_enabled',
+        kind: 'scalar',
+        jsonName: 'e2eeEnabled',
+        T: 8 /*ScalarType.BOOL*/,
+      },
     ]);
   }
 }

package/src/helpers/MediaPlaybackWatchdog.ts

@@ -23,8 +23,10 @@ export class MediaPlaybackWatchdog {
   private tracer: Tracer;
   private controller = new AbortController();
   private pendingTimer: ReturnType<typeof setTimeout> | undefined;
+  private settleTimer: ReturnType<typeof setTimeout> | undefined;
   private attempt = 0;
   private disposed = false;
+  private stopped = false;
 
   constructor(opts: MediaPlaybackWatchdogOptions) {
     this.element = opts.element;
@@ -46,33 +48,47 @@ export class MediaPlaybackWatchdog {
     if (this.disposed) return;
     this.disposed = true;
     this.controller.abort();
+    this.clearTimers();
+  };
+
+  private clearTimers = () => {
     if (this.pendingTimer) clearTimeout(this.pendingTimer);
     this.pendingTimer = undefined;
+    if (this.settleTimer) clearTimeout(this.settleTimer);
+    this.settleTimer = undefined;
   };
 
   private onPlaying = () => {
-    if (this.attempt > 0) {
-      this.tracer.trace('mediaPlayback.recover.success', {
-        kind: this.kind,
-        attempts: this.attempt,
-      });
-    }
-    this.attempt = 0;
     if (this.pendingTimer) clearTimeout(this.pendingTimer);
     this.pendingTimer = undefined;
+    if (this.attempt === 0 || this.settleTimer) return;
+    this.settleTimer ??= setTimeout(this.onSettled, 1000);
+  };
+
+  private onSettled = () => {
+    this.settleTimer = undefined;
+    if (this.element.paused) return;
+    this.tracer.trace('mediaPlayback.recover.success', {
+      kind: this.kind,
+      attempts: this.attempt,
+    });
+    this.attempt = 0;
+    this.stopped = false;
   };
 
   private onPauseOrSuspend = (event: Event) => {
-    if (this.disposed) return;
+    if (this.disposed || this.stopped) return;
     this.tracer.trace('mediaPlayback.paused', {
       kind: this.kind,
       reason: event.type,
     });
+    if (this.settleTimer) clearTimeout(this.settleTimer);
+    this.settleTimer = undefined;
     this.scheduleRecovery();
   };
 
   private scheduleRecovery = () => {
-    if (this.disposed || this.pendingTimer) return;
+    if (this.disposed || this.stopped || this.pendingTimer) return;
     const skipReason = this.computeSkipReason();
     if (skipReason) {
       this.tracer.trace('mediaPlayback.recover.skipped', {
@@ -81,6 +97,16 @@ export class MediaPlaybackWatchdog {
       });
       return;
     }
+
+    if (this.attempt >= 10) {
+      this.stopped = true;
+      this.clearTimers();
+      this.tracer.trace('mediaPlayback.recover.giveUp', {
+        kind: this.kind,
+        attempts: this.attempt,
+      });
+      return;
+    }
     const delay = this.attempt === 0 ? 0 : retryInterval(this.attempt);
     this.pendingTimer = setTimeout(this.attemptPlay, delay);
   };
@@ -109,13 +135,6 @@ export class MediaPlaybackWatchdog {
     } catch (err) {
       if (this.disposed) return;
       this.logger.warn(`Failed to recover ${this.kind} playback`, err);
-      if (this.attempt >= 10) {
-        this.tracer.trace('mediaPlayback.recover.giveUp', {
-          kind: this.kind,
-          attempts: this.attempt,
-        });
-        return;
-      }
       this.scheduleRecovery();
     }
   };

package/src/helpers/TypedEventEmitter.ts

@@ -0,0 +1,71 @@
+import { ScopedLogger, videoLoggerSystem } from '../logger';
+
+export type EventMap = Record<string, unknown>;
+
+export type Listener<P> = (payload: P) => void | Promise<void>;
+
+/**
+ * Tiny, type-safe event emitter.
+ *
+ * Usage styles:
+ * - compose: `private readonly events = new TypedEventEmitter<MyMap>()`
+ * - extend:  `class Foo extends TypedEventEmitter<MyMap> {}`
+ *
+ * Listener exceptions (sync throw or rejected promise) are caught and logged,
+ * so one bad listener cannot break dispatch for the rest.
+ */
+export class TypedEventEmitter<M extends EventMap> {
+  protected readonly logger: ScopedLogger;
+  private readonly byEvent = new Map<keyof M, Set<Listener<any>>>();
+
+  constructor(logger: ScopedLogger | string = 'TypedEventEmitter') {
+    this.logger =
+      typeof logger === 'string' ? videoLoggerSystem.getLogger(logger) : logger;
+  }
+
+  on = <E extends keyof M>(event: E, fn: Listener<M[E]>): (() => void) => {
+    let listeners = this.byEvent.get(event);
+    if (!listeners) {
+      listeners = new Set();
+      this.byEvent.set(event, listeners);
+    }
+    listeners.add(fn as Listener<any>);
+    return () => this.off(event, fn);
+  };
+
+  off = <E extends keyof M>(event: E, fn: Listener<M[E]>): void => {
+    const listeners = this.byEvent.get(event);
+    if (!listeners) return;
+    listeners.delete(fn as Listener<any>);
+    if (listeners.size === 0) this.byEvent.delete(event);
+  };
+
+  emit = <E extends keyof M>(event: E, payload: M[E]): void => {
+    const listeners = this.byEvent.get(event);
+    if (!listeners || listeners.size === 0) return;
+    for (const listener of [...listeners]) {
+      this.invoke(() => listener(payload), event);
+    }
+  };
+
+  removeAllListeners = (event?: keyof M): void => {
+    if (event === undefined) {
+      this.byEvent.clear();
+    } else {
+      this.byEvent.delete(event);
+    }
+  };
+
+  private invoke = (run: () => void | Promise<void>, event: keyof M): void => {
+    try {
+      const result = run();
+      if (result && typeof (result as Promise<void>).then === 'function') {
+        (result as Promise<void>).catch((err) => {
+          this.logger.warn(`Listener for '${String(event)}' rejected`, err);
+        });
+      }
+    } catch (err) {
+      this.logger.warn(`Listener for '${String(event)}' threw`, err);
+    }
+  };
+}

package/src/helpers/__tests__/MediaPlaybackWatchdog.test.ts

@@ -28,20 +28,33 @@ const createMediaElement = (
   state: FakeMediaState = {},
 ) => {
   const el = document.createElement(kind) as HTMLMediaElement;
-  Object.defineProperty(el, 'srcObject', { writable: true });
+  Object.defineProperty(el, 'srcObject', {
+    value: 'srcObject' in state ? state.srcObject : new MediaStream(),
+    writable: true,
+  });
   Object.defineProperty(el, 'paused', { writable: true, configurable: true });
   Object.defineProperty(el, 'readyState', {
+    value: state.readyState ?? 4,
+    writable: true,
+    configurable: true,
+  });
+  Object.defineProperty(el, 'ended', {
+    value: state.ended ?? false,
     writable: true,
     configurable: true,
   });
-  Object.defineProperty(el, 'ended', { writable: true, configurable: true });
-  el.srcObject = 'srcObject' in state ? state.srcObject : new MediaStream();
-  el.paused = state.paused ?? true;
-  el.readyState = state.readyState ?? 4;
-  el.ended = state.ended ?? false;
+  setPaused(el, state.paused ?? true);
   return el;
 };
 
+const setPaused = (el: HTMLMediaElement, paused: boolean) => {
+  Object.defineProperty(el, 'paused', {
+    value: paused,
+    writable: true,
+    configurable: true,
+  });
+};
+
 type SetupOpts = {
   kind?: 'audio' | 'video';
   state?: FakeMediaState;
@@ -111,15 +124,131 @@ describe('MediaPlaybackWatchdog', () => {
     await vi.advanceTimersByTimeAsync(6000);
     expect(play).toHaveBeenCalledTimes(2);
 
-    // Simulate the element actually starting to play.
+    // Simulate the element actually starting to play, and staying up long
+    // enough for the recovery to count as settled.
+    setPaused(el, false);
     el.dispatchEvent(new Event('playing'));
+    await vi.advanceTimersByTimeAsync(1000);
 
-    // A subsequent pause should still trigger a fresh recovery attempt.
+    // A subsequent pause should trigger a fresh, immediate recovery attempt.
+    setPaused(el, true);
     el.dispatchEvent(new Event('pause'));
     await vi.advanceTimersByTimeAsync(0);
     expect(play).toHaveBeenCalledTimes(3);
   });
 
+  it('backs off instead of retrying immediately when playback has not settled', async () => {
+    el.dispatchEvent(new Event('pause'));
+    await vi.advanceTimersByTimeAsync(0);
+    expect(play).toHaveBeenCalledTimes(1);
+
+    // resumed, but re-paused before the settle delay elapsed
+    setPaused(el, false);
+    el.dispatchEvent(new Event('playing'));
+    expect(tracer.trace).not.toHaveBeenCalledWith(
+      'mediaPlayback.recover.success',
+      {
+        kind: 'audio',
+        attempts: 1,
+      },
+    );
+    await vi.advanceTimersByTimeAsync(500);
+    setPaused(el, true);
+    el.dispatchEvent(new Event('pause'));
+
+    // the next attempt is subject to backoff, not scheduled on the next tick
+    await vi.advanceTimersByTimeAsync(0);
+    expect(play).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(6000);
+    expect(play).toHaveBeenCalledTimes(2);
+  });
+
+  it('stops fighting an element that re-pauses after every successful play', async () => {
+    setup({ kind: 'video' });
+    // Safari re-pauses the element right after play() resolves. This used to
+    // reset the attempt counter, so the loop spun with a zero delay forever.
+    play.mockImplementation(async () => {
+      setPaused(el, false);
+      el.dispatchEvent(new Event('playing'));
+      setPaused(el, true);
+      el.dispatchEvent(new Event('pause'));
+    });
+
+    el.dispatchEvent(new Event('pause'));
+    for (let i = 0; i < 20; i++) {
+      await vi.advanceTimersByTimeAsync(6000);
+    }
+
+    expect(play).toHaveBeenCalledTimes(10);
+    expect(tracer.trace).toHaveBeenCalledWith('mediaPlayback.recover.giveUp', {
+      kind: 'video',
+      attempts: 10,
+    });
+
+    // External playback can still emit `playing` after the watchdog gave up
+    // (for example from a user gesture or another playback helper). If it
+    // re-pauses before settling, it must not revive the watchdog or trace a
+    // false recovery success.
+    setPaused(el, false);
+    el.dispatchEvent(new Event('playing'));
+    setPaused(el, true);
+    el.dispatchEvent(new Event('pause'));
+    await vi.advanceTimersByTimeAsync(1000);
+
+    expect(tracer.trace).not.toHaveBeenCalledWith(
+      'mediaPlayback.recover.success',
+      {
+        kind: 'video',
+        attempts: 10,
+      },
+    );
+
+    // and it stays stopped, without tracing the pause storm
+    const traceMock = tracer.trace as unknown as MockInstance;
+    const tracesBefore = traceMock.mock.calls.length;
+    for (let i = 0; i < 100; i++) {
+      el.dispatchEvent(new Event('pause'));
+    }
+    await vi.advanceTimersByTimeAsync(6000);
+
+    expect(play).toHaveBeenCalledTimes(10);
+    expect(traceMock.mock.calls.length).toBe(tracesBefore);
+  });
+
+  it('revives once playback genuinely holds for the settle window', async () => {
+    setup({ kind: 'video' });
+    play.mockImplementation(async () => {
+      setPaused(el, false);
+      el.dispatchEvent(new Event('playing'));
+      setPaused(el, true);
+      el.dispatchEvent(new Event('pause'));
+    });
+
+    el.dispatchEvent(new Event('pause'));
+    for (let i = 0; i < 20; i++) {
+      await vi.advanceTimersByTimeAsync(6000);
+    }
+    expect(play).toHaveBeenCalledTimes(10); // gave up
+
+    play.mockResolvedValue(undefined);
+    setPaused(el, false);
+    el.dispatchEvent(new Event('playing'));
+    await vi.advanceTimersByTimeAsync(1500);
+
+    expect(tracer.trace).toHaveBeenCalledWith('mediaPlayback.recover.success', {
+      kind: 'video',
+      attempts: 10,
+    });
+
+    // recovery is live again: the attempt counter was reset, so a fresh pause
+    // gets an immediate attempt rather than being ignored
+    setPaused(el, true);
+    el.dispatchEvent(new Event('pause'));
+    await vi.advanceTimersByTimeAsync(0);
+    expect(play).toHaveBeenCalledTimes(11);
+  });
+
   it('does not attempt recovery when srcObject is null', async () => {
     setup({ state: { srcObject: null } });
 

package/src/helpers/__tests__/TypedEventEmitter.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TypedEventEmitter } from '../TypedEventEmitter';
+
+type TestEvents = {
+  hello: string;
+  ping: { n: number };
+  empty: undefined;
+};
+
+describe('TypedEventEmitter', () => {
+  let emitter: TypedEventEmitter<TestEvents>;
+
+  beforeEach(() => {
+    emitter = new TypedEventEmitter<TestEvents>();
+  });
+
+  it('invokes listeners registered with on()', () => {
+    const listener = vi.fn();
+    emitter.on('hello', listener);
+    emitter.emit('hello', 'world');
+    expect(listener).toHaveBeenCalledWith('world');
+  });
+
+  it('returns an unsubscribe function from on()', () => {
+    const listener = vi.fn();
+    const unsubscribe = emitter.on('hello', listener);
+    unsubscribe();
+    emitter.emit('hello', 'world');
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('removes listeners via off()', () => {
+    const listener = vi.fn();
+    emitter.on('hello', listener);
+    emitter.off('hello', listener);
+    emitter.emit('hello', 'world');
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('supports multiple listeners for the same event', () => {
+    const a = vi.fn();
+    const b = vi.fn();
+    emitter.on('ping', a);
+    emitter.on('ping', b);
+    emitter.emit('ping', { n: 1 });
+    expect(a).toHaveBeenCalledWith({ n: 1 });
+    expect(b).toHaveBeenCalledWith({ n: 1 });
+  });
+
+  it('deduplicates identical listener references', () => {
+    const listener = vi.fn();
+    emitter.on('hello', listener);
+    emitter.on('hello', listener);
+    emitter.emit('hello', 'once');
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it('isolates a throwing listener from subsequent listeners', () => {
+    const bad = vi.fn(() => {
+      throw new Error('boom');
+    });
+    const good = vi.fn();
+    emitter.on('hello', bad);
+    emitter.on('hello', good);
+    expect(() => emitter.emit('hello', 'world')).not.toThrow();
+    expect(bad).toHaveBeenCalled();
+    expect(good).toHaveBeenCalledWith('world');
+  });
+
+  it('isolates a rejecting async listener', async () => {
+    const rejected = vi.fn(async () => {
+      throw new Error('async boom');
+    });
+    const good = vi.fn();
+    emitter.on('hello', rejected);
+    emitter.on('hello', good);
+    expect(() => emitter.emit('hello', 'world')).not.toThrow();
+    expect(good).toHaveBeenCalled();
+    // allow microtask to settle; rejection should have been swallowed by the emitter
+    await Promise.resolve();
+  });
+
+  it('is safe to call off() from within a listener (current emit still fires siblings)', () => {
+    const sibling = vi.fn();
+    const self = vi.fn(() => {
+      emitter.off('hello', self);
+    });
+    emitter.on('hello', self);
+    emitter.on('hello', sibling);
+    emitter.emit('hello', 'world');
+    expect(self).toHaveBeenCalledTimes(1);
+    expect(sibling).toHaveBeenCalledTimes(1);
+    // second emit should not invoke self again
+    emitter.emit('hello', 'again');
+    expect(self).toHaveBeenCalledTimes(1);
+    expect(sibling).toHaveBeenCalledTimes(2);
+  });
+
+  it('is safe to add a listener from within a listener (added listener does not fire in current emit)', () => {
+    const later = vi.fn();
+    emitter.on('hello', () => {
+      emitter.on('hello', later);
+    });
+    emitter.emit('hello', 'first');
+    expect(later).not.toHaveBeenCalled();
+    emitter.emit('hello', 'second');
+    expect(later).toHaveBeenCalledWith('second');
+  });
+
+  it('removeAllListeners() clears every subscription when called without args', () => {
+    const a = vi.fn();
+    const b = vi.fn();
+    emitter.on('hello', a);
+    emitter.on('ping', b);
+    emitter.removeAllListeners();
+    emitter.emit('hello', 'world');
+    emitter.emit('ping', { n: 1 });
+    expect(a).not.toHaveBeenCalled();
+    expect(b).not.toHaveBeenCalled();
+  });
+
+  it('removeAllListeners(event) clears only that event', () => {
+    const a = vi.fn();
+    const b = vi.fn();
+    emitter.on('hello', a);
+    emitter.on('ping', b);
+    emitter.removeAllListeners('hello');
+    emitter.emit('hello', 'world');
+    emitter.emit('ping', { n: 1 });
+    expect(a).not.toHaveBeenCalled();
+    expect(b).toHaveBeenCalledWith({ n: 1 });
+  });
+});

package/src/helpers/__tests__/ViewportTracker.test.ts

@@ -38,8 +38,7 @@ describe('ViewportTracker', () => {
 
   it('updates participant viewportVisibilityState as visibility changes', () => {
     let visibilityHandler:
-      | ((entry: IntersectionObserverEntry) => void)
-      | undefined;
+      ((entry: IntersectionObserverEntry) => void) | undefined;
     vi.spyOn(viewportTracker, 'observe').mockImplementation((_el, handler) => {
       visibilityHandler = handler;
       return vi.fn();

package/src/helpers/ensureExhausted.ts

@@ -1,5 +1,7 @@
 import { videoLoggerSystem } from '../logger';
 
-export const ensureExhausted = (x: never, message: string) => {
-  videoLoggerSystem.getLogger('helpers').warn(message, x);
+export const ensureExhausted = (x: never, message?: string) => {
+  if (message) {
+    videoLoggerSystem.getLogger('helpers').warn(message, x);
+  }
 };

package/src/permissions/PermissionsContext.ts

@@ -1,4 +1,8 @@
-import { CallSettingsResponse, OwnCapability } from '../gen/coordinator';
+import {
+  CallSettingsResponse,
+  OwnCapability,
+  RequestPermissionRequestPermissionsEnum,
+} from '../gen/coordinator';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { ensureExhausted } from '../helpers/ensureExhausted';
 
@@ -70,20 +74,21 @@ export class PermissionsContext {
    * @param settings the call settings to check against (optional).
    */
   canRequest = (
-    permission: OwnCapability,
+    permission: RequestPermissionRequestPermissionsEnum,
     settings: CallSettingsResponse | undefined = this.settings,
   ) => {
     if (!settings) return false;
 
     const { audio, video, screensharing } = settings;
     switch (permission) {
-      case OwnCapability.SEND_AUDIO:
+      case RequestPermissionRequestPermissionsEnum.SEND_AUDIO:
         return audio.access_request_enabled;
-      case OwnCapability.SEND_VIDEO:
+      case RequestPermissionRequestPermissionsEnum.SEND_VIDEO:
         return video.access_request_enabled;
-      case OwnCapability.SCREENSHARE:
+      case RequestPermissionRequestPermissionsEnum.SCREENSHARE:
         return screensharing.access_request_enabled;
       default:
+        ensureExhausted(permission);
         return false;
     }
   };

package/src/reporting/ClientEventReporter.ts

@@ -33,18 +33,12 @@ export type ClientEventStage =
   | 'FirstAudioFrame';
 
 export type MediaPermissionState =
-  | 'INITIATED'
-  | 'FAILED'
-  | 'GRANTED'
-  | 'NOT_INITIATED';
+  'INITIATED' | 'FAILED' | 'GRANTED' | 'NOT_INITIATED';
 
 export type ReportedIceState = 'CONNECTED' | 'FAILED' | 'NOT_CONNECTED';
 
 export type JoinReason =
-  | 'first-attempt'
-  | 'network-available'
-  | 'migration'
-  | 'full-rejoin';
+  'first-attempt' | 'network-available' | 'migration' | 'full-rejoin';
 
 export type ClientEventStandardCode =
   | 'CLIENT_ABORTED'

package/src/rtc/BasePeerConnection.ts

@@ -8,6 +8,8 @@ import {
   TrackType,
   WebsocketReconnectStrategy,
 } from '../gen/video/sfu/models/models';
+import type { E2EEManager } from './e2ee/E2EEManager';
+import { hasInsertableStreams } from './e2ee/transformSupport';
 import { NegotiationError } from './NegotiationError';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
@@ -35,6 +37,7 @@ export abstract class BasePeerConnection {
   protected readonly state: CallState;
   protected readonly dispatcher: Dispatcher;
   protected readonly clientPublishOptions?: ClientPublishOptions;
+  protected readonly e2ee?: E2EEManager;
   protected tag: string;
   protected sfuClient: StreamSfuClient;
 
@@ -75,6 +78,7 @@ export abstract class BasePeerConnection {
       tag,
       enableTracing,
       clientPublishOptions,
+      e2ee,
       iceRestartDelay = 2500,
       statsTimestampDriftThresholdMs = 0,
     }: BasePeerConnectionOpts,
@@ -85,6 +89,7 @@ export abstract class BasePeerConnection {
     this.dispatcher = dispatcher;
     this.iceRestartDelay = iceRestartDelay;
     this.clientPublishOptions = clientPublishOptions;
+    this.e2ee = e2ee;
     this.tag = tag;
     this.onReconnectionNeeded = onReconnectionNeeded;
     this.onIceConnected = onIceConnected;
@@ -114,7 +119,13 @@ export abstract class BasePeerConnection {
   }
 
   private createPeerConnection = (connectionConfig?: RTCConfiguration) => {
-    const pc = new RTCPeerConnection(connectionConfig);
+    const config: RTCConfiguration = { ...connectionConfig };
+    // The legacy Insertable Streams path requires this non-standard flag.
+    if (this.e2ee && hasInsertableStreams()) {
+      // @ts-expect-error not part of the standard lib yet
+      config.encodedInsertableStreams = true;
+    }
+    const pc = new RTCPeerConnection(config);
     pc.addEventListener('icecandidate', this.onIceCandidate);
     pc.addEventListener('icecandidateerror', this.onIceCandidateError);
     pc.addEventListener(

package/src/rtc/Publisher.ts

@@ -166,6 +166,14 @@ export class Publisher extends BasePeerConnection {
       toRTCDegradationPreference(publishOption.degradationPreference) ??
       'maintain-framerate';
     await transceiver.sender.setParameters(params);
+    if (this.e2ee) {
+      this.e2ee.encrypt(
+        transceiver.sender,
+        publishOption.codec?.name.toLowerCase(),
+        TrackType[publishOption.trackType],
+      );
+      this.logger.debug('E2EE encryptor attached to sender');
+    }
 
     await this.negotiate();
   };

package/src/rtc/Subscriber.ts

@@ -151,8 +151,13 @@ export class Subscriber extends BasePeerConnection {
         trackLookupPrefix: trackId,
         track: primaryStream,
         trackType,
+        receiver: this.e2ee ? e.receiver : undefined,
       });
       return;
+    } else if (this.e2ee) {
+      const { userId } = participantToUpdate;
+      this.e2ee.decrypt(e.receiver, userId, TrackType[trackType]);
+      this.logger.debug('E2EE decryptor attached to receiver', userId);
     }
 
     const streamKindProp = trackTypeToParticipantStreamKey(trackType);