livekit-client 1.11.3 → 1.12.0

package/src/room/RTCEngine.ts

@@ -1,4 +1,5 @@
 import EventEmitter from 'eventemitter3';
+import type { MediaAttributes } from 'sdp-transform';
 import { SignalClient } from '../api/SignalClient';
 import type { SignalOptions } from '../api/SignalClient';
 import log from '../logger';
@@ -9,17 +10,23 @@ import {
   DataPacket,
   DataPacket_Kind,
   DisconnectReason,
+  ParticipantInfo,
   ReconnectReason,
+  Room as RoomModel,
   SpeakerInfo,
   TrackInfo,
   UserPacket,
 } from '../proto/livekit_models';
 import {
   AddTrackRequest,
+  ConnectionQualityUpdate,
   JoinResponse,
   LeaveRequest,
   ReconnectResponse,
   SignalTarget,
+  StreamStateUpdate,
+  SubscriptionPermissionUpdate,
+  SubscriptionResponse,
   TrackPublishedResponse,
 } from '../proto/livekit_rtc';
 import PCTransport, { PCEvents } from './PCTransport';
@@ -43,6 +50,7 @@ import type { TrackPublishOptions, VideoCodec } from './track/options';
 import {
   Mutex,
   isCloud,
+  isVideoCodec,
   isWeb,
   sleep,
   supportsAddTrack,
@@ -161,6 +169,17 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       [DataPacket_Kind.LOSSY, true],
       [DataPacket_Kind.RELIABLE, true],
     ]);
+
+    this.client.onParticipantUpdate = (updates) =>
+      this.emit(EngineEvent.ParticipantUpdate, updates);
+    this.client.onConnectionQuality = (update) =>
+      this.emit(EngineEvent.ConnectionQualityUpdate, update);
+    this.client.onRoomUpdate = (update) => this.emit(EngineEvent.RoomUpdate, update);
+    this.client.onSubscriptionError = (resp) => this.emit(EngineEvent.SubscriptionError, resp);
+    this.client.onSubscriptionPermissionUpdate = (update) =>
+      this.emit(EngineEvent.SubscriptionPermissionUpdate, update);
+    this.client.onSpeakersChanged = (update) => this.emit(EngineEvent.SpeakersChanged, update);
+    this.client.onStreamStateUpdate = (update) => this.emit(EngineEvent.StreamStateChanged, update);
   }
 
   async join(
@@ -187,6 +206,8 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       if (!this.subscriberPrimary) {
         this.negotiate();
       }
+      this.setupSignalClientCallbacks();
+
       this.clientConfiguration = joinResponse.clientConfiguration;
 
       return joinResponse;
@@ -217,30 +238,63 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       this.removeAllListeners();
       this.deregisterOnLineListener();
       this.clearPendingReconnect();
-      if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
-        this.publisher.pc.getSenders().forEach((sender) => {
-          try {
-            // TODO: react-native-webrtc doesn't have removeTrack yet.
-            if (this.publisher?.pc.removeTrack) {
-              this.publisher?.pc.removeTrack(sender);
-            }
-          } catch (e) {
-            log.warn('could not removeTrack', { error: e });
-          }
-        });
-        this.publisher.close();
-        this.publisher = undefined;
-      }
-      if (this.subscriber) {
-        this.subscriber.close();
-        this.subscriber = undefined;
-      }
-      await this.client.close();
+      await this.cleanupPeerConnections();
+      await this.cleanupClient();
     } finally {
       unlock();
     }
   }
 
+  async cleanupPeerConnections() {
+    if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
+      this.publisher.pc.getSenders().forEach((sender) => {
+        try {
+          // TODO: react-native-webrtc doesn't have removeTrack yet.
+          if (this.publisher?.pc.removeTrack) {
+            this.publisher?.pc.removeTrack(sender);
+          }
+        } catch (e) {
+          log.warn('could not removeTrack', { error: e });
+        }
+      });
+    }
+    if (this.publisher) {
+      this.publisher.close();
+      this.publisher = undefined;
+    }
+    if (this.subscriber) {
+      this.subscriber.close();
+      this.subscriber = undefined;
+    }
+
+    this.primaryPC = undefined;
+
+    const dcCleanup = (dc: RTCDataChannel | undefined) => {
+      if (!dc) return;
+      dc.close();
+      dc.onbufferedamountlow = null;
+      dc.onclose = null;
+      dc.onclosing = null;
+      dc.onerror = null;
+      dc.onmessage = null;
+      dc.onopen = null;
+    };
+    dcCleanup(this.lossyDC);
+    dcCleanup(this.lossyDCSub);
+    dcCleanup(this.reliableDC);
+    dcCleanup(this.reliableDCSub);
+
+    this.lossyDC = undefined;
+    this.lossyDCSub = undefined;
+    this.reliableDC = undefined;
+    this.reliableDCSub = undefined;
+  }
+
+  async cleanupClient() {
+    await this.client.close();
+    this.client.resetCallbacks();
+  }
+
   addTrack(req: AddTrackRequest): Promise<TrackInfo> {
     if (this.pendingTrackResolvers[req.cid]) {
       throw new TrackInvalidError('a track with the same ID has already been published');
@@ -313,6 +367,14 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     this.participantSid = joinResponse.participant?.sid;
 
     const rtcConfig = this.makeRTCConfiguration(joinResponse);
+
+    if (this.signalOpts?.e2eeEnabled) {
+      log.debug('E2EE - setting up transports with insertable streams');
+      //  this makes sure that no data is sent before the transforms are ready
+      // @ts-ignore
+      rtcConfig.encodedInsertableStreams = true;
+    }
+
     const googConstraints = { optional: [{ googDscp: true }] };
     this.publisher = new PCTransport(rtcConfig, googConstraints);
     this.subscriber = new PCTransport(rtcConfig);
@@ -384,7 +446,9 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     };
 
     this.createDataChannels();
+  }
 
+  private setupSignalClientCallbacks() {
     // configure signaling client
     this.client.onAnswer = async (sd) => {
       if (!this.publisher) {
@@ -392,7 +456,7 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       }
       log.debug('received server answer', {
         RTCSdpType: sd.type,
-        signalingState: this.publisher.pc.signalingState,
+        signalingState: this.publisher.pc.signalingState.toString(),
       });
       await this.publisher.setRemoteDescription(sd);
     };
@@ -417,7 +481,7 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       }
       log.debug('received server offer', {
         RTCSdpType: sd.type,
-        signalingState: this.subscriber.pc.signalingState,
+        signalingState: this.subscriber.pc.signalingState.toString(),
       });
       await this.subscriber.setRemoteDescription(sd);
 
@@ -646,11 +710,13 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     encodings?: RTCRtpEncodingParameters[],
   ) {
     if (supportsTransceiver()) {
-      return this.createTransceiverRTCRtpSender(track, opts, encodings);
+      const sender = await this.createTransceiverRTCRtpSender(track, opts, encodings);
+      return sender;
     }
     if (supportsAddTrack()) {
-      log.debug('using add-track fallback');
-      return this.createRTCRtpSender(track.mediaStreamTrack);
+      log.warn('using add-track fallback');
+      const sender = await this.createRTCRtpSender(track.mediaStreamTrack);
+      return sender;
     }
     throw new UnexpectedConnectionState('Required webRTC APIs not supported on this device');
   }
@@ -662,7 +728,6 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     encodings?: RTCRtpEncodingParameters[],
   ) {
     // store RTCRtpSender
-    // @ts-ignore
     if (supportsTransceiver()) {
       return this.createSimulcastTransceiverSender(track, simulcastTrack, opts, encodings);
     }
@@ -683,7 +748,13 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       throw new UnexpectedConnectionState('publisher is closed');
     }
 
-    const transceiverInit: RTCRtpTransceiverInit = { direction: 'sendonly' };
+    const streams: MediaStream[] = [];
+
+    if (track.mediaStream) {
+      streams.push(track.mediaStream);
+    }
+
+    const transceiverInit: RTCRtpTransceiverInit = { direction: 'sendonly', streams };
     if (encodings) {
       transceiverInit.sendEncodings = encodings;
     }
@@ -692,6 +763,7 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       track.mediaStreamTrack,
       transceiverInit,
     );
+
     if (track.kind === Track.Kind.Video && opts.videoCodec) {
       this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
       track.codec = opts.videoCodec;
@@ -819,7 +891,7 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       }
 
       if (recoverable) {
-        this.handleDisconnect('reconnect', ReconnectReason.RR_UNKOWN);
+        this.handleDisconnect('reconnect', ReconnectReason.RR_UNKNOWN);
       } else {
         log.info(
           `could not recover connection after ${this.reconnectAttempts} attempts, ${
@@ -858,12 +930,8 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
       if (this.client.isConnected) {
         await this.client.sendLeave();
       }
-      await this.client.close();
-      this.primaryPC = undefined;
-      this.publisher?.close();
-      this.publisher = undefined;
-      this.subscriber?.close();
-      this.subscriber = undefined;
+      await this.cleanupPeerConnections();
+      await this.cleanupClient();
 
       let joinResponse: JoinResponse;
       try {
@@ -919,6 +987,7 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     this.emit(EngineEvent.Resuming);
 
     try {
+      this.setupSignalClientCallbacks();
       const res = await this.client.reconnect(this.url, this.token, this.participantSid, reason);
       if (res) {
         const rtcConfig = this.makeRTCConfiguration(res);
@@ -1178,6 +1247,9 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
         return;
       };
 
+      if (this.isClosed) {
+        reject('cannot negotiate on closed engine');
+      }
       this.on(EngineEvent.Closing, handleClosed);
 
       const negotiationTimeout = setTimeout(() => {
@@ -1197,13 +1269,24 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
         });
       });
 
+      this.publisher.once(PCEvents.RTPVideoPayloadTypes, (rtpTypes: MediaAttributes['rtp']) => {
+        const rtpMap = new Map<number, VideoCodec>();
+        rtpTypes.forEach((rtp) => {
+          const codec = rtp.codec.toLowerCase();
+          if (isVideoCodec(codec)) {
+            rtpMap.set(rtp.payload, codec);
+          }
+        });
+        this.emit(EngineEvent.RTPVideoMapUpdate, rtpMap);
+      });
+
       this.publisher.negotiate((e) => {
         cleanup();
         reject(e);
         if (e instanceof NegotiationError) {
           this.fullReconnectOnNext = true;
         }
-        this.handleDisconnect('negotiation', ReconnectReason.RR_UNKOWN);
+        this.handleDisconnect('negotiation', ReconnectReason.RR_UNKNOWN);
       });
     });
   }
@@ -1318,5 +1401,15 @@ export type EngineEventCallbacks = {
   activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void;
   dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void;
   transportsCreated: (publisher: PCTransport, subscriber: PCTransport) => void;
+  /** @internal */
+  trackSenderAdded: (track: Track, sender: RTCRtpSender) => void;
+  rtpVideoMapUpdate: (rtpMap: Map<number, VideoCodec>) => void;
   dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
+  participantUpdate: (infos: ParticipantInfo[]) => void;
+  roomUpdate: (room: RoomModel) => void;
+  connectionQualityUpdate: (update: ConnectionQualityUpdate) => void;
+  speakersChanged: (speakerUpdates: SpeakerInfo[]) => void;
+  streamStateChanged: (update: StreamStateUpdate) => void;
+  subscriptionError: (resp: SubscriptionResponse) => void;
+  subscriptionPermissionUpdate: (update: SubscriptionPermissionUpdate) => void;
 };

package/src/room/Room.ts

@@ -1,6 +1,8 @@
 import EventEmitter from 'eventemitter3';
 import 'webrtc-adapter';
 import { toProtoSessionDescription } from '../api/SignalClient';
+import { EncryptionEvent } from '../e2ee';
+import { E2EEManager } from '../e2ee/E2eeManager';
 import log from '../logger';
 import type {
   InternalRoomConnectOptions,
@@ -56,7 +58,7 @@ import RemoteTrackPublication from './track/RemoteTrackPublication';
 import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
 import type { AdaptiveStreamSettings } from './track/types';
-import { getNewAudioContext } from './track/utils';
+import { getNewAudioContext, sourceToKind } from './track/utils';
 import type { SimulationOptions, SimulationScenario } from './types';
 import {
   Future,
@@ -112,6 +114,9 @@ class Room extends EventEmitter<RoomEventCallbacks> {
   /** options of room */
   options: InternalRoomOptions;
 
+  /** reflects the sender encryption status of the local participant */
+  isE2EEEnabled: boolean = false;
+
   private roomInfo?: RoomModel;
 
   private identityToSid: Map<string, string>;
@@ -131,12 +136,12 @@ class Room extends EventEmitter<RoomEventCallbacks> {
 
   private disconnectLock: Mutex;
 
+  private e2eeManager: E2EEManager | undefined;
+
   private cachedParticipantSids: Array<string>;
 
   private connectionReconcileInterval?: ReturnType<typeof setInterval>;
 
-  private activeDeviceMap: Map<MediaDeviceKind, string>;
-
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -164,15 +169,17 @@ class Room extends EventEmitter<RoomEventCallbacks> {
     this.maybeCreateEngine();
 
     this.disconnectLock = new Mutex();
-    this.activeDeviceMap = new Map();
+
+    this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
+
     if (this.options.videoCaptureDefaults.deviceId) {
-      this.activeDeviceMap.set(
+      this.localParticipant.activeDeviceMap.set(
         'videoinput',
         unwrapConstraint(this.options.videoCaptureDefaults.deviceId),
       );
     }
     if (this.options.audioCaptureDefaults.deviceId) {
-      this.activeDeviceMap.set(
+      this.localParticipant.activeDeviceMap.set(
         'audioinput',
         unwrapConstraint(this.options.audioCaptureDefaults.deviceId),
       );
@@ -181,7 +188,42 @@ class Room extends EventEmitter<RoomEventCallbacks> {
       this.switchActiveDevice('audiooutput', unwrapConstraint(this.options.audioOutput.deviceId));
     }
 
-    this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
+    if (this.options.e2ee) {
+      this.setupE2EE();
+    }
+  }
+
+  /**
+   * @experimental
+   */
+  async setE2EEEnabled(enabled: boolean) {
+    if (this.e2eeManager) {
+      await Promise.all([
+        this.localParticipant.setE2EEEnabled(enabled),
+        this.e2eeManager.setParticipantCryptorEnabled(enabled),
+      ]);
+    } else {
+      throw Error('e2ee not configured, please set e2ee settings within the room options');
+    }
+  }
+
+  private setupE2EE() {
+    if (this.options.e2ee) {
+      this.e2eeManager = new E2EEManager(this.options.e2ee);
+      this.e2eeManager.on(
+        EncryptionEvent.ParticipantEncryptionStatusChanged,
+        (enabled, participant) => {
+          if (participant instanceof LocalParticipant) {
+            this.isE2EEEnabled = enabled;
+          }
+          this.emit(RoomEvent.ParticipantEncryptionStatusChanged, enabled, participant);
+        },
+      );
+      this.e2eeManager.on(EncryptionEvent.Error, (error) =>
+        this.emit(RoomEvent.EncryptionError, error),
+      );
+      this.e2eeManager?.setup(this);
+    }
   }
 
   /**
@@ -221,15 +263,14 @@ class Room extends EventEmitter<RoomEventCallbacks> {
 
     this.engine = new RTCEngine(this.options);
 
-    this.engine.client.onParticipantUpdate = this.handleParticipantUpdates;
-    this.engine.client.onRoomUpdate = this.handleRoomUpdate;
-    this.engine.client.onSpeakersChanged = this.handleSpeakersChanged;
-    this.engine.client.onStreamStateUpdate = this.handleStreamStateUpdate;
-    this.engine.client.onSubscriptionPermissionUpdate = this.handleSubscriptionPermissionUpdate;
-    this.engine.client.onConnectionQuality = this.handleConnectionQualityUpdate;
-    this.engine.client.onSubscriptionError = this.handleSubscriptionError;
-
     this.engine
+      .on(EngineEvent.ParticipantUpdate, this.handleParticipantUpdates)
+      .on(EngineEvent.RoomUpdate, this.handleRoomUpdate)
+      .on(EngineEvent.SpeakersChanged, this.handleSpeakersChanged)
+      .on(EngineEvent.StreamStateChanged, this.handleStreamStateUpdate)
+      .on(EngineEvent.ConnectionQualityUpdate, this.handleConnectionQualityUpdate)
+      .on(EngineEvent.SubscriptionError, this.handleSubscriptionError)
+      .on(EngineEvent.SubscriptionPermissionUpdate, this.handleSubscriptionPermissionUpdate)
       .on(
         EngineEvent.MediaTrackAdded,
         (mediaTrack: MediaStreamTrack, stream: MediaStream, receiver?: RTCRtpReceiver) => {
@@ -275,6 +316,9 @@ class Room extends EventEmitter<RoomEventCallbacks> {
     if (this.localParticipant) {
       this.localParticipant.setupEngine(this.engine);
     }
+    if (this.e2eeManager) {
+      this.e2eeManager.setupEngine(this.engine);
+    }
   }
 
   /**
@@ -394,6 +438,7 @@ class Room extends EventEmitter<RoomEventCallbacks> {
         adaptiveStream:
           typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
         maxRetries: connectOptions.maxRetries,
+        e2eeEnabled: !!this.e2eeManager,
       },
       abortController.signal,
     );
@@ -588,10 +633,8 @@ class Room extends EventEmitter<RoomEventCallbacks> {
     let req: SimulateScenario | undefined;
     switch (scenario) {
       case 'signal-reconnect':
-        await this.engine.client.close();
-        if (this.engine.client.onClose) {
-          this.engine.client.onClose('simulate disconnect');
-        }
+        // @ts-expect-error function is private
+        await this.engine.client.handleOnClose('simulate disconnect');
         break;
       case 'speaker':
         req = SimulateScenario.fromPartial({
@@ -627,17 +670,13 @@ class Room extends EventEmitter<RoomEventCallbacks> {
         break;
       case 'resume-reconnect':
         this.engine.failNext();
-        await this.engine.client.close();
-        if (this.engine.client.onClose) {
-          this.engine.client.onClose('simulate resume-reconnect');
-        }
+        // @ts-expect-error function is private
+        await this.engine.client.handleOnClose('simulate resume-disconnect');
         break;
       case 'full-reconnect':
         this.engine.fullReconnectOnNext = true;
-        await this.engine.client.close();
-        if (this.engine.client.onClose) {
-          this.engine.client.onClose('simulate full-reconnect');
-        }
+        // @ts-expect-error function is private
+        await this.engine.client.handleOnClose('simulate full-reconnect');
         break;
       case 'force-tcp':
       case 'force-tls':
@@ -744,7 +783,7 @@ class Room extends EventEmitter<RoomEventCallbacks> {
   }
 
   getActiveDevice(kind: MediaDeviceKind): string | undefined {
-    return this.activeDeviceMap.get(kind);
+    return this.localParticipant.activeDeviceMap.get(kind);
   }
 
   /**
@@ -818,7 +857,7 @@ class Room extends EventEmitter<RoomEventCallbacks> {
       }
     }
     if (deviceHasChanged && success) {
-      this.activeDeviceMap.set(kind, deviceId);
+      this.localParticipant.activeDeviceMap.set(kind, deviceId);
       this.emit(RoomEvent.ActiveDeviceChanged, kind, deviceId);
     }
 
@@ -1524,6 +1563,16 @@ class Room extends EventEmitter<RoomEventCallbacks> {
         this.emit(RoomEvent.LocalAudioSilenceDetected, pub);
       }
     }
+    const deviceId = await pub.track?.getDeviceId();
+    const deviceKind = sourceToKind(pub.source);
+    if (
+      deviceKind &&
+      deviceId &&
+      deviceId !== this.localParticipant.activeDeviceMap.get(deviceKind)
+    ) {
+      this.localParticipant.activeDeviceMap.set(deviceKind, deviceId);
+      this.emit(RoomEvent.ActiveDeviceChanged, deviceKind, deviceId);
+    }
   };
 
   private onLocalTrackUnpublished = (pub: LocalTrackPublication) => {
@@ -1597,7 +1646,9 @@ class Room extends EventEmitter<RoomEventCallbacks> {
         }),
         new LocalVideoTrack(
           publishOptions.useRealTracks
-            ? (await navigator.mediaDevices.getUserMedia({ video: true })).getVideoTracks()[0]
+            ? (
+                await window.navigator.mediaDevices.getUserMedia({ video: true })
+              ).getVideoTracks()[0]
             : createDummyVideoStreamTrack(
                 160 * participantOptions.aspectRatios[0] ?? 1,
                 160,
@@ -1760,6 +1811,8 @@ export type RoomEventCallbacks = {
   audioPlaybackChanged: (playing: boolean) => void;
   signalConnected: () => void;
   recordingStatusChanged: (recording: boolean) => void;
+  participantEncryptionStatusChanged: (encrypted: boolean, participant?: Participant) => void;
+  encryptionError: (error: Error) => void;
   dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
   activeDeviceChanged: (kind: MediaDeviceKind, deviceId: string) => void;
 };

package/src/room/defaults.ts

@@ -20,7 +20,7 @@ export const publishDefaults: TrackPublishDefaults = {
   screenShareEncoding: ScreenSharePresets.h1080fps15.encoding,
   stopMicTrackOnMute: false,
   videoCodec: 'vp8',
-  backupCodec: { codec: 'vp8', encoding: VideoPresets.h540.encoding },
+  backupCodec: false,
 } as const;
 
 export const audioDefaults: AudioCaptureOptions = {

package/src/room/events.ts

@@ -273,6 +273,9 @@ export enum RoomEvent {
    */
   RecordingStatusChanged = 'recordingStatusChanged',
 
+  ParticipantEncryptionStatusChanged = 'participantEncryptionStatusChanged',
+
+  EncryptionError = 'encryptionError',
   /**
    * Emits whenever the current buffer status of a data channel changes
    * args: (isLow: boolean, kind: [[DataPacket_Kind]])
@@ -443,6 +446,9 @@ export enum ParticipantEvent {
    * args: (prevPermissions: [[ParticipantPermission]])
    */
   ParticipantPermissionsChanged = 'participantPermissionsChanged',
+
+  /** @internal */
+  PCTrackAdded = 'pcTrackAdded',
 }
 
 /** @internal */
@@ -460,7 +466,15 @@ export enum EngineEvent {
   MediaTrackAdded = 'mediaTrackAdded',
   ActiveSpeakersUpdate = 'activeSpeakersUpdate',
   DataPacketReceived = 'dataPacketReceived',
+  RTPVideoMapUpdate = 'rtpVideoMapUpdate',
   DCBufferStatusChanged = 'dcBufferStatusChanged',
+  ParticipantUpdate = 'participantUpdate',
+  RoomUpdate = 'roomUpdate',
+  SpeakersChanged = 'speakersChanged',
+  StreamStateChanged = 'streamStateChanged',
+  ConnectionQualityUpdate = 'connectionQualityUpdate',
+  SubscriptionError = 'subscriptionError',
+  SubscriptionPermissionUpdate = 'subscriptionPermissionUpdate',
 }
 
 export enum TrackEvent {