livekit-client 2.0.3 → 2.0.4

package/src/room/events.ts

@@ -491,6 +491,7 @@ export enum EngineEvent {
   RemoteMute = 'remoteMute',
   SubscribedQualityUpdate = 'subscribedQualityUpdate',
   LocalTrackUnpublished = 'localTrackUnpublished',
+  Offline = 'offline',
 }
 
 export enum TrackEvent {

package/src/room/participant/LocalParticipant.ts

@@ -513,6 +513,10 @@ export default class LocalParticipant extends Participant {
     track: LocalTrack | MediaStreamTrack,
     options?: TrackPublishOptions,
   ): Promise<LocalTrackPublication> {
+    if (track instanceof LocalAudioTrack) {
+      track.setAudioContext(this.audioContext);
+    }
+
     await this.reconnectFuture?.promise;
     if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
       await this.pendingPublishPromises.get(track);
@@ -566,10 +570,6 @@ export default class LocalParticipant extends Participant {
       });
     }
 
-    if (track instanceof LocalAudioTrack) {
-      track.setAudioContext(this.audioContext);
-    }
-
     // is it already published? if so skip
     let existingPublication: LocalTrackPublication | undefined;
     this.trackPublications.forEach((publication) => {

package/src/room/track/LocalAudioTrack.ts

@@ -51,6 +51,11 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (this.isMuted) {
+        this.log.debug('Track already muted', this.logContext);
+        return this;
+      }
+
       // disabled special handling as it will cause BT headsets to switch communication modes
       if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
         this.log.debug('stopping mic track', this.logContext);
@@ -67,6 +72,11 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (!this.isMuted) {
+        this.log.debug('Track already unmuted', this.logContext);
+        return this;
+      }
+
       const deviceHasChanged =
         this._constraints.deviceId &&
         this._mediaStreamTrack.getSettings().deviceId !==

package/src/room/track/LocalTrack.ts

@@ -8,6 +8,7 @@ import { Mutex, compareVersions, isMobile, sleep } from '../utils';
 import { Track, attachToElement, detachTrack } from './Track';
 import type { VideoCodec } from './options';
 import type { TrackProcessor } from './processor/types';
+import type { ReplaceTrackOptions } from './types';
 
 const defaultDimensionsTimeout = 1000;
 
@@ -224,18 +225,34 @@ export default abstract class LocalTrack<
     return this;
   }
 
-  async replaceTrack(track: MediaStreamTrack, userProvidedTrack = true) {
+  async replaceTrack(track: MediaStreamTrack, options?: ReplaceTrackOptions): Promise<typeof this>;
+  async replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<typeof this>;
+  async replaceTrack(
+    track: MediaStreamTrack,
+    userProvidedOrOptions: boolean | ReplaceTrackOptions | undefined,
+  ) {
     if (!this.sender) {
       throw new TrackInvalidError('unable to replace an unpublished track');
     }
 
+    let userProvidedTrack: boolean | undefined;
+    let stopProcessor: boolean | undefined;
+
+    if (typeof userProvidedOrOptions === 'boolean') {
+      userProvidedTrack = userProvidedOrOptions;
+    } else if (userProvidedOrOptions !== undefined) {
+      userProvidedTrack = userProvidedOrOptions.userProvidedTrack;
+      stopProcessor = userProvidedOrOptions.stopProcessor;
+    }
+
+    this.providedByUser = userProvidedTrack ?? true;
+
     this.log.debug('replace MediaStreamTrack', this.logContext);
     await this.setMediaStreamTrack(track);
     // this must be synced *after* setting mediaStreamTrack above, since it relies
     // on the previous state in order to cleanup
-    this.providedByUser = userProvidedTrack;
 
-    if (this.processor) {
+    if (stopProcessor && this.processor) {
       await this.stopProcessor();
     }
     return this;

package/src/room/track/LocalVideoTrack.ts

@@ -118,6 +118,11 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
   async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (this.isMuted) {
+        this.log.debug('Track already muted', this.logContext);
+        return this;
+      }
+
       if (this.source === Track.Source.Camera && !this.isUserProvided) {
         this.log.debug('stopping camera track', this.logContext);
         // also stop the track, so that camera indicator is turned off
@@ -133,6 +138,11 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
   async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (!this.isMuted) {
+        this.log.debug('Track already unmuted', this.logContext);
+        return this;
+      }
+
       if (this.source === Track.Source.Camera && !this.isUserProvided) {
         this.log.debug('reacquiring camera track', this.logContext);
         await this.restartTrack();

package/src/room/track/options.ts

@@ -257,6 +257,15 @@ export interface VideoEncoding {
   priority?: RTCPriorityType;
 }
 
+export interface VideoPresetOptions {
+  width: number;
+  height: number;
+  aspectRatio?: number;
+  maxBitrate: number;
+  maxFramerate?: number;
+  priority?: RTCPriorityType;
+}
+
 export class VideoPreset {
   encoding: VideoEncoding;
 
@@ -264,20 +273,44 @@ export class VideoPreset {
 
   height: number;
 
+  aspectRatio?: number;
+
+  constructor(videoPresetOptions: VideoPresetOptions);
   constructor(
     width: number,
     height: number,
     maxBitrate: number,
     maxFramerate?: number,
     priority?: RTCPriorityType,
+  );
+  constructor(
+    widthOrOptions: number | VideoPresetOptions,
+    height?: number,
+    maxBitrate?: number,
+    maxFramerate?: number,
+    priority?: RTCPriorityType,
   ) {
-    this.width = width;
-    this.height = height;
-    this.encoding = {
-      maxBitrate,
-      maxFramerate,
-      priority,
-    };
+    if (typeof widthOrOptions === 'object') {
+      this.width = widthOrOptions.width;
+      this.height = widthOrOptions.height;
+      this.aspectRatio = widthOrOptions.aspectRatio;
+      this.encoding = {
+        maxBitrate: widthOrOptions.maxBitrate,
+        maxFramerate: widthOrOptions.maxFramerate,
+        priority: widthOrOptions.priority,
+      };
+    } else if (height !== undefined && maxBitrate !== undefined) {
+      this.width = widthOrOptions;
+      this.height = height;
+      this.aspectRatio = widthOrOptions / height;
+      this.encoding = {
+        maxBitrate,
+        maxFramerate,
+        priority,
+      };
+    } else {
+      throw new TypeError('Unsupported options: provide at least width, height and maxBitrate');
+    }
   }
 
   get resolution(): VideoResolution {
@@ -285,7 +318,7 @@ export class VideoPreset {
       width: this.width,
       height: this.height,
       frameRate: this.encoding.maxFramerate,
-      aspectRatio: this.width / this.height,
+      aspectRatio: this.aspectRatio,
     };
   }
 }

package/src/room/track/types.ts

@@ -23,3 +23,8 @@ export type AdaptiveStreamSettings = {
    */
   pauseVideoInBackground?: boolean;
 };
+
+export interface ReplaceTrackOptions {
+  userProvidedTrack?: boolean;
+  stopProcessor?: boolean;
+}