livekit-client 2.0.0 → 2.0.2

package/src/e2ee/worker/e2ee.worker.ts

@@ -84,7 +84,7 @@ onmessage = (ev) => {
       }
       break;
     case 'removeTransform':
-      unsetCryptorParticipant(data.trackId);
+      unsetCryptorParticipant(data.trackId, data.participantIdentity);
       break;
     case 'updateCodec':
       getTrackCryptor(data.participantIdentity, data.trackId).setVideoCodec(data.codec);
@@ -125,7 +125,9 @@ async function handleRatchetRequest(data: RatchetRequestMessage['data']) {
 }
 
 function getTrackCryptor(participantIdentity: string, trackId: string) {
-  let cryptor = participantCryptors.find((c) => c.getTrackId() === trackId);
+  let cryptor = participantCryptors.find(
+    (c) => c.getParticipantIdentity() === participantIdentity && c.getTrackId() === trackId,
+  );
   if (!cryptor) {
     workerLogger.info('creating new cryptor for', { participantIdentity });
     if (!keyProviderOptions) {
@@ -172,8 +174,10 @@ function getSharedKeyHandler() {
   return sharedKeyHandler;
 }
 
-function unsetCryptorParticipant(trackId: string) {
-  participantCryptors.find((c) => c.getTrackId() === trackId)?.unsetParticipant();
+function unsetCryptorParticipant(trackId: string, participantIdentity: string) {
+  participantCryptors
+    .find((c) => c.getParticipantIdentity() === participantIdentity && c.getTrackId() === trackId)
+    ?.unsetParticipant();
 }
 
 function setEncryptionEnabled(enable: boolean, participantIdentity: string) {

package/src/proto/livekit_models_pb.ts

@@ -301,6 +301,16 @@ export enum DisconnectReason {
    * @generated from enum value: JOIN_FAILURE = 7;
    */
   JOIN_FAILURE = 7,
+
+  /**
+   * @generated from enum value: MIGRATION = 8;
+   */
+  MIGRATION = 8,
+
+  /**
+   * @generated from enum value: SIGNAL_CLOSE = 9;
+   */
+  SIGNAL_CLOSE = 9,
 }
 // Retrieve enum metadata with: proto3.getEnumType(DisconnectReason)
 proto3.util.setEnumType(DisconnectReason, "livekit.DisconnectReason", [
@@ -312,6 +322,8 @@ proto3.util.setEnumType(DisconnectReason, "livekit.DisconnectReason", [
   { no: 5, name: "ROOM_DELETED" },
   { no: 6, name: "STATE_MISMATCH" },
   { no: 7, name: "JOIN_FAILURE" },
+  { no: 8, name: "MIGRATION" },
+  { no: 9, name: "SIGNAL_CLOSE" },
 ]);
 
 /**

package/src/proto/livekit_rtc_pb.ts

@@ -1208,6 +1208,7 @@ export class LeaveRequest extends Message<LeaveRequest> {
   /**
    * sent when server initiates the disconnect due to server-restart
    * indicates clients should attempt full-reconnect sequence
+   * NOTE: `can_reconnect` obsoleted by `action` starting in protocol version 13
    *
    * @generated from field: bool can_reconnect = 1;
    */
@@ -1218,6 +1219,16 @@ export class LeaveRequest extends Message<LeaveRequest> {
    */
   reason = DisconnectReason.UNKNOWN_REASON;
 
+  /**
+   * @generated from field: livekit.LeaveRequest.Action action = 3;
+   */
+  action = LeaveRequest_Action.DISCONNECT;
+
+  /**
+   * @generated from field: livekit.RegionSettings regions = 4;
+   */
+  regions?: RegionSettings;
+
   constructor(data?: PartialMessage<LeaveRequest>) {
     super();
     proto3.util.initPartial(data, this);
@@ -1228,6 +1239,8 @@ export class LeaveRequest extends Message<LeaveRequest> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "can_reconnect", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
     { no: 2, name: "reason", kind: "enum", T: proto3.getEnumType(DisconnectReason) },
+    { no: 3, name: "action", kind: "enum", T: proto3.getEnumType(LeaveRequest_Action) },
+    { no: 4, name: "regions", kind: "message", T: RegionSettings },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LeaveRequest {
@@ -1247,6 +1260,40 @@ export class LeaveRequest extends Message<LeaveRequest> {
   }
 }
 
+/**
+ * indicates action clients should take on receiving this message
+ *
+ * @generated from enum livekit.LeaveRequest.Action
+ */
+export enum LeaveRequest_Action {
+  /**
+   * should disconnect
+   *
+   * @generated from enum value: DISCONNECT = 0;
+   */
+  DISCONNECT = 0,
+
+  /**
+   * should attempt a resume with `reconnect=1` in join URL
+   *
+   * @generated from enum value: RESUME = 1;
+   */
+  RESUME = 1,
+
+  /**
+   * should attempt a reconnect, i. e. no `reconnect=1`
+   *
+   * @generated from enum value: RECONNECT = 2;
+   */
+  RECONNECT = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(LeaveRequest_Action)
+proto3.util.setEnumType(LeaveRequest_Action, "livekit.LeaveRequest.Action", [
+  { no: 0, name: "DISCONNECT" },
+  { no: 1, name: "RESUME" },
+  { no: 2, name: "RECONNECT" },
+]);
+
 /**
  * message to indicate published video track dimensions are changing
  *
@@ -1947,6 +1994,11 @@ export class SyncState extends Message<SyncState> {
    */
   offer?: SessionDescription;
 
+  /**
+   * @generated from field: repeated string track_sids_disabled = 6;
+   */
+  trackSidsDisabled: string[] = [];
+
   constructor(data?: PartialMessage<SyncState>) {
     super();
     proto3.util.initPartial(data, this);
@@ -1960,6 +2012,7 @@ export class SyncState extends Message<SyncState> {
     { no: 3, name: "publish_tracks", kind: "message", T: TrackPublishedResponse, repeated: true },
     { no: 4, name: "data_channels", kind: "message", T: DataChannelInfo, repeated: true },
     { no: 5, name: "offer", kind: "message", T: SessionDescription },
+    { no: 6, name: "track_sids_disabled", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SyncState {

package/src/room/PCTransport.ts

@@ -5,7 +5,7 @@ import { debounce } from 'ts-debounce';
 import log, { LoggerNames, getLogger } from '../logger';
 import { NegotiationError, UnexpectedConnectionState } from './errors';
 import type { LoggerOptions } from './types';
-import { ddExtensionURI, isChromiumBased, isSVCCodec } from './utils';
+import { ddExtensionURI, isSVCCodec } from './utils';
 
 /** @internal */
 interface TrackBitrateInfo {
@@ -42,8 +42,6 @@ export default class PCTransport extends EventEmitter {
 
   private config?: RTCConfiguration;
 
-  private mediaConstraints: Record<string, unknown>;
-
   private log = log;
 
   private loggerOptions: LoggerOptions;
@@ -76,24 +74,16 @@ export default class PCTransport extends EventEmitter {
 
   onTrack?: (ev: RTCTrackEvent) => void;
 
-  constructor(
-    config?: RTCConfiguration,
-    mediaConstraints: Record<string, unknown> = {},
-    loggerOptions: LoggerOptions = {},
-  ) {
+  constructor(config?: RTCConfiguration, loggerOptions: LoggerOptions = {}) {
     super();
     this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.PCTransport);
     this.loggerOptions = loggerOptions;
     this.config = config;
-    this.mediaConstraints = mediaConstraints;
     this._pc = this.createPC();
   }
 
   private createPC() {
-    const pc = isChromiumBased()
-      ? // @ts-expect-error chrome allows additional media constraints to be passed into the RTCPeerConnection constructor
-        new RTCPeerConnection(this.config, this.mediaConstraints)
-      : new RTCPeerConnection(this.config);
+    const pc = new RTCPeerConnection(this.config);
 
     pc.onicecandidate = (ev) => {
       if (!ev.candidate) return;

package/src/room/PCTransportManager.ts

@@ -71,8 +71,7 @@ export class PCTransportManager {
 
     this.isPublisherConnectionRequired = !subscriberPrimary;
     this.isSubscriberConnectionRequired = subscriberPrimary;
-    const googConstraints = { optional: [{ googDscp: true }] };
-    this.publisher = new PCTransport(rtcConfig, googConstraints, loggerOptions);
+    this.publisher = new PCTransport(rtcConfig, loggerOptions);
     this.subscriber = new PCTransport(rtcConfig, loggerOptions);
 
     this.publisher.onConnectionStateChange = this.updateState;

package/src/room/RTCEngine.ts

@@ -1271,11 +1271,15 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     */
     const autoSubscribe = this.signalOpts?.autoSubscribe ?? true;
     const trackSids = new Array<string>();
+    const trackSidsDisabled = new Array<string>();
 
     remoteTracks.forEach((track) => {
       if (track.isDesired !== autoSubscribe) {
         trackSids.push(track.trackSid);
       }
+      if (!track.isEnabled) {
+        trackSidsDisabled.push(track.trackSid);
+      }
     });
 
     this.client.sendSyncState(
@@ -1299,6 +1303,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         }),
         publishTracks: getTrackPublicationInfo(localTracks),
         dataChannels: this.dataChannelsInfo(),
+        trackSidsDisabled,
       }),
     );
   }

package/src/room/Room.ts

@@ -1776,7 +1776,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private onLocalTrackPublished = async (pub: LocalTrackPublication) => {
+    pub.track?.getProcessor()?.onPublish?.(this);
+
     this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
+
     if (pub.track instanceof LocalAudioTrack) {
       const trackIsSilent = await pub.track.checkForSilence();
       if (trackIsSilent) {

package/src/room/events.ts

@@ -27,7 +27,14 @@ export enum RoomEvent {
 
   /**
    * When disconnected from room. This fires when room.disconnect() is called or
-   * when an unrecoverable connection issue had occured
+   * when an unrecoverable connection issue had occured.
+   *
+   * DisconnectReason can be used to determine why the participant was disconnected. Notable reasons are
+   * - DUPLICATE_IDENTITY: another client with the same identity has joined the room
+   * - PARTICIPANT_REMOVED: participant was removed by RemoveParticipant API
+   * - ROOM_DELETED: the room has ended via DeleteRoom API
+   *
+   * args: ([[DisconnectReason]])
    */
   Disconnected = 'disconnected',
 

package/src/room/participant/LocalParticipant.ts

@@ -888,7 +888,6 @@ export default class LocalParticipant extends Participant {
     }
 
     this.addTrackPublication(publication);
-
     // send event for publication
     this.emit(ParticipantEvent.LocalTrackPublished, publication);
     return publication;

package/src/room/track/LocalAudioTrack.ts

@@ -6,17 +6,17 @@ import { isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
 import type { AudioCaptureOptions } from './options';
-import type { TrackProcessor } from './processor/types';
+import type { AudioProcessorOptions, TrackProcessor } from './processor/types';
 import { constraintsForOptions, detectSilence } from './utils';
 
-export default class LocalAudioTrack extends LocalTrack {
+export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   /** @internal */
   stopOnMute: boolean = false;
 
-  private audioContext?: AudioContext;
-
   private prevStats?: AudioSenderStats;
 
+  protected processor?: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions> | undefined;
+
   /**
    *
    * @param mediaTrack
@@ -48,7 +48,7 @@ export default class LocalAudioTrack extends LocalTrack {
     );
   }
 
-  async mute(): Promise<LocalAudioTrack> {
+  async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
       // disabled special handling as it will cause BT headsets to switch communication modes
@@ -64,7 +64,7 @@ export default class LocalAudioTrack extends LocalTrack {
     }
   }
 
-  async unmute(): Promise<LocalAudioTrack> {
+  async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
       const deviceHasChanged =
@@ -99,7 +99,7 @@ export default class LocalAudioTrack extends LocalTrack {
     await this.restart(constraints);
   }
 
-  protected async restart(constraints?: MediaTrackConstraints): Promise<LocalTrack> {
+  protected async restart(constraints?: MediaTrackConstraints): Promise<typeof this> {
     const track = await super.restart(constraints);
     this.checkForSilence();
     return track;
@@ -139,7 +139,7 @@ export default class LocalAudioTrack extends LocalTrack {
     this.prevStats = stats;
   };
 
-  async setProcessor(processor: TrackProcessor<this['kind']>) {
+  async setProcessor(processor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions>) {
     const unlock = await this.processorLock.lock();
     try {
       if (!this.audioContext) {
@@ -150,9 +150,6 @@ export default class LocalAudioTrack extends LocalTrack {
       if (this.processor) {
         await this.stopProcessor();
       }
-      if (this.kind === 'unknown') {
-        throw TypeError('cannot set processor on track of unknown kind');
-      }
 
       const processorOptions = {
         kind: this.kind,

package/src/room/track/LocalTrack.ts

@@ -11,7 +11,9 @@ import type { TrackProcessor } from './processor/types';
 
 const defaultDimensionsTimeout = 1000;
 
-export default abstract class LocalTrack extends Track {
+export default abstract class LocalTrack<
+  TrackKind extends Track.Kind = Track.Kind,
+> extends Track<TrackKind> {
   /** @internal */
   sender?: RTCRtpSender;
 
@@ -34,10 +36,12 @@ export default abstract class LocalTrack extends Track {
 
   protected processorElement?: HTMLMediaElement;
 
-  protected processor?: TrackProcessor<this['kind']>;
+  protected processor?: TrackProcessor<TrackKind, any>;
 
   protected processorLock: Mutex;
 
+  protected audioContext?: AudioContext;
+
   /**
    *
    * @param mediaTrack
@@ -47,7 +51,7 @@ export default abstract class LocalTrack extends Track {
    */
   protected constructor(
     mediaTrack: MediaStreamTrack,
-    kind: Track.Kind,
+    kind: TrackKind,
     constraints?: MediaTrackConstraints,
     userProvidedTrack = false,
     loggerOptions?: LoggerOptions,
@@ -128,21 +132,28 @@ export default abstract class LocalTrack extends Track {
       this._constraints = newTrack.getConstraints();
     }
     let processedTrack: MediaStreamTrack | undefined;
-    if (this.processor && newTrack && this.processorElement) {
-      this.log.debug('restarting processor', this.logContext);
-      if (this.kind === 'unknown') {
-        throw TypeError('cannot set processor on track of unknown kind');
-      }
+    if (this.processor && newTrack) {
+      const unlock = await this.processorLock.lock();
+      try {
+        this.log.debug('restarting processor', this.logContext);
+        if (this.kind === 'unknown') {
+          throw TypeError('cannot set processor on track of unknown kind');
+        }
 
-      attachToElement(newTrack, this.processorElement);
-      // ensure the processorElement itself stays muted
-      this.processorElement.muted = true;
-      await this.processor.restart({
-        track: newTrack,
-        kind: this.kind,
-        element: this.processorElement,
-      });
-      processedTrack = this.processor.processedTrack;
+        if (this.processorElement) {
+          attachToElement(newTrack, this.processorElement);
+          // ensure the processorElement itself stays muted
+          this.processorElement.muted = true;
+        }
+        await this.processor.restart({
+          track: newTrack,
+          kind: this.kind,
+          element: this.processorElement,
+        });
+        processedTrack = this.processor.processedTrack;
+      } finally {
+        unlock();
+      }
     }
     if (this.sender) {
       await this.sender.replaceTrack(processedTrack ?? newTrack);
@@ -200,17 +211,17 @@ export default abstract class LocalTrack extends Track {
     return DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId);
   }
 
-  async mute(): Promise<LocalTrack> {
+  async mute() {
     this.setTrackMuted(true);
     return this;
   }
 
-  async unmute(): Promise<LocalTrack> {
+  async unmute() {
     this.setTrackMuted(false);
     return this;
   }
 
-  async replaceTrack(track: MediaStreamTrack, userProvidedTrack = true): Promise<LocalTrack> {
+  async replaceTrack(track: MediaStreamTrack, userProvidedTrack = true) {
     if (!this.sender) {
       throw new TrackInvalidError('unable to replace an unpublished track');
     }
@@ -227,7 +238,7 @@ export default abstract class LocalTrack extends Track {
     return this;
   }
 
-  protected async restart(constraints?: MediaTrackConstraints): Promise<LocalTrack> {
+  protected async restart(constraints?: MediaTrackConstraints) {
     if (!constraints) {
       constraints = this._constraints;
     }
@@ -408,7 +419,7 @@ export default abstract class LocalTrack extends Track {
    * @param showProcessedStreamLocally
    * @returns
    */
-  async setProcessor(processor: TrackProcessor<this['kind']>, showProcessedStreamLocally = true) {
+  async setProcessor(processor: TrackProcessor<TrackKind>, showProcessedStreamLocally = true) {
     const unlock = await this.processorLock.lock();
     try {
       this.log.debug('setting up processor', this.logContext);
@@ -418,7 +429,8 @@ export default abstract class LocalTrack extends Track {
       if (this.kind === 'unknown') {
         throw TypeError('cannot set processor on track of unknown kind');
       }
-      this.processorElement = this.processorElement ?? document.createElement(this.kind);
+      this.processorElement =
+        this.processorElement ?? (document.createElement(this.kind) as HTMLMediaElement);
 
       attachToElement(this._mediaStreamTrack, this.processorElement);
       this.processorElement.muted = true;
@@ -433,6 +445,7 @@ export default abstract class LocalTrack extends Track {
         kind: this.kind,
         track: this._mediaStreamTrack,
         element: this.processorElement,
+        audioContext: this.audioContext,
       };
 
       await processor.init(processorOptions);

package/src/room/track/LocalVideoTrack.ts

@@ -30,7 +30,7 @@ export class SimulcastTrackInfo {
 
 const refreshSubscribedCodecAfterNewCodec = 5000;
 
-export default class LocalVideoTrack extends LocalTrack {
+export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
   /* @internal */
   signalClient?: SignalClient;
 
@@ -115,7 +115,7 @@ export default class LocalVideoTrack extends LocalTrack {
     }
   }
 
-  async mute(): Promise<LocalVideoTrack> {
+  async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
       if (this.source === Track.Source.Camera && !this.isUserProvided) {
@@ -130,7 +130,7 @@ export default class LocalVideoTrack extends LocalTrack {
     }
   }
 
-  async unmute(): Promise<LocalVideoTrack> {
+  async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
       if (this.source === Track.Source.Camera && !this.isUserProvided) {

package/src/room/track/RemoteAudioTrack.ts

@@ -7,7 +7,7 @@ import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
 import type { AudioOutputOptions } from './options';
 
-export default class RemoteAudioTrack extends RemoteTrack {
+export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
   private prevStats?: AudioReceiverStats;
 
   private elementVolume: number | undefined;

package/src/room/track/RemoteTrack.ts

@@ -3,14 +3,16 @@ import { monitorFrequency } from '../stats';
 import type { LoggerOptions } from '../types';
 import { Track } from './Track';
 
-export default abstract class RemoteTrack extends Track {
+export default abstract class RemoteTrack<
+  TrackKind extends Track.Kind = Track.Kind,
+> extends Track<TrackKind> {
   /** @internal */
   receiver?: RTCRtpReceiver;
 
   constructor(
     mediaTrack: MediaStreamTrack,
     sid: string,
-    kind: Track.Kind,
+    kind: TrackKind,
     receiver?: RTCRtpReceiver,
     loggerOptions?: LoggerOptions,
   ) {

package/src/room/track/RemoteVideoTrack.ts

@@ -12,7 +12,7 @@ import type { AdaptiveStreamSettings } from './types';
 
 const REACTION_DELAY = 100;
 
-export default class RemoteVideoTrack extends RemoteTrack {
+export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
   private prevStats?: VideoReceiverStats;
 
   private elementInfos: ElementInfo[] = [];

package/src/room/track/Track.ts

@@ -24,8 +24,10 @@ export enum VideoQuality {
   MEDIUM = ProtoQuality.MEDIUM,
   HIGH = ProtoQuality.HIGH,
 }
-export abstract class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEventCallbacks>) {
-  kind: Track.Kind;
+export abstract class Track<
+  TrackKind extends Track.Kind = Track.Kind,
+> extends (EventEmitter as new () => TypedEventEmitter<TrackEventCallbacks>) {
+  readonly kind: TrackKind;
 
   attachedElements: HTMLMediaElement[] = [];
 
@@ -67,7 +69,7 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
 
   protected constructor(
     mediaTrack: MediaStreamTrack,
-    kind: Track.Kind,
+    kind: TrackKind,
     loggerOptions: LoggerOptions = {},
   ) {
     super();

package/src/room/track/processor/types.ts

@@ -1,3 +1,4 @@
+import type Room from '../../Room';
 import type { Track } from '../Track';
 
 /**
@@ -7,6 +8,7 @@ export type ProcessorOptions<T extends Track.Kind> = {
   kind: T;
   track: MediaStreamTrack;
   element?: HTMLMediaElement;
+  audioContext?: AudioContext;
 };
 
 /**
@@ -33,4 +35,6 @@ export interface TrackProcessor<
   restart: (opts: U) => Promise<void>;
   destroy: () => Promise<void>;
   processedTrack?: MediaStreamTrack;
+  onPublish?: (room: Room) => Promise<void>;
+  onUnpublish?: () => Promise<void>;
 }