livekit-client 1.6.5 → 1.6.7

package/src/room/RTCEngine.ts

@@ -118,8 +118,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private clientConfiguration?: ClientConfiguration;
 
-  private connectedServerAddr?: string;
-
   private attemptingReconnect: boolean = false;
 
   private reconnectPolicy: ReconnectPolicy;
@@ -136,6 +134,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private closingLock: Mutex;
 
+  private shouldFailNext: boolean = false;
+
   constructor(private options: InternalRoomOptions) {
     super();
     this.client = new SignalClient();
@@ -247,7 +247,13 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     });
   }
 
-  removeTrack(sender: RTCRtpSender) {
+  /**
+   * Removes sender from PeerConnection, returning true if it was removed successfully
+   * and a negotiation is necessary
+   * @param sender
+   * @returns
+   */
+  removeTrack(sender: RTCRtpSender): boolean {
     if (sender.track && this.pendingTrackResolvers[sender.track.id]) {
       const { reject } = this.pendingTrackResolvers[sender.track.id];
       if (reject) {
@@ -257,9 +263,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
     try {
       this.publisher?.pc.removeTrack(sender);
+      return true;
     } catch (e: unknown) {
       log.warn('failed to remove track', { error: e, method: 'removeTrack' });
     }
+    return false;
   }
 
   updateMuteStatus(trackSid: string, muted: boolean) {
@@ -270,8 +278,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     return this.reliableDCSub?.readyState;
   }
 
-  get connectedServerAddress(): string | undefined {
-    return this.connectedServerAddr;
+  async getConnectedServerAddress(): Promise<string | undefined> {
+    if (this.primaryPC === undefined) {
+      return undefined;
+    }
+    return getConnectedAddress(this.primaryPC);
   }
 
   private configure(joinResponse: JoinResponse) {
@@ -317,11 +328,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     primaryPC.onconnectionstatechange = async () => {
       log.debug(`primary PC state changed ${primaryPC.connectionState}`);
       if (primaryPC.connectionState === 'connected') {
-        try {
-          this.connectedServerAddr = await getConnectedAddress(primaryPC);
-        } catch (e) {
-          log.warn('could not get connected server address', { error: e });
-        }
         const shouldEmit = this.pcState === PCState.New;
         this.pcState = PCState.Connected;
         if (shouldEmit) {
@@ -334,7 +340,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
           this.handleDisconnect(
             'primary peerconnection',
-            false,
             subscriberPrimary
               ? ReconnectReason.REASON_SUBSCRIBER_FAILED
               : ReconnectReason.REASON_PUBLISHER_FAILED,
@@ -348,7 +353,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       if (secondaryPC.connectionState === 'failed') {
         this.handleDisconnect(
           'secondary peerconnection',
-          false,
           subscriberPrimary
             ? ReconnectReason.REASON_PUBLISHER_FAILED
             : ReconnectReason.REASON_SUBSCRIBER_FAILED,
@@ -419,7 +423,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     };
 
     this.client.onClose = () => {
-      this.handleDisconnect('signal', false, ReconnectReason.REASON_SIGNAL_DISCONNECTED);
+      this.handleDisconnect('signal', ReconnectReason.REASON_SIGNAL_DISCONNECTED);
     };
 
     this.client.onLeave = (leave?: LeaveRequest) => {
@@ -690,11 +694,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   // websocket reconnect behavior. if websocket is interrupted, and the PeerConnection
   // continues to work, we can reconnect to websocket to continue the session
   // after a number of retries, we'll close and give up permanently
-  private handleDisconnect = (
-    connection: string,
-    signalEvents: boolean = false,
-    disconnectReason?: ReconnectReason,
-  ) => {
+  private handleDisconnect = (connection: string, disconnectReason?: ReconnectReason) => {
     if (this._isClosed) {
       return;
     }
@@ -731,12 +731,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.clearReconnectTimeout();
     this.reconnectTimeout = CriticalTimers.setTimeout(
-      () => this.attemptReconnect(signalEvents, disconnectReason),
+      () => this.attemptReconnect(disconnectReason),
       delay,
     );
   };
 
-  private async attemptReconnect(signalEvents: boolean = false, reason?: ReconnectReason) {
+  private async attemptReconnect(reason?: ReconnectReason) {
     if (this._isClosed) {
       return;
     }
@@ -756,35 +756,26 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     try {
       this.attemptingReconnect = true;
       if (this.fullReconnectOnNext) {
-        await this.restartConnection(signalEvents);
+        await this.restartConnection();
       } else {
-        await this.resumeConnection(signalEvents, reason);
+        await this.resumeConnection(reason);
       }
       this.clearPendingReconnect();
       this.fullReconnectOnNext = false;
     } catch (e) {
       this.reconnectAttempts += 1;
-      let reconnectRequired = false;
       let recoverable = true;
-      let requireSignalEvents = false;
       if (e instanceof UnexpectedConnectionState) {
         log.debug('received unrecoverable error', { error: e });
         // unrecoverable
         recoverable = false;
       } else if (!(e instanceof SignalReconnectError)) {
         // cannot resume
-        reconnectRequired = true;
-      }
-
-      // when we flip from resume to reconnect
-      // we need to fire the right reconnecting events
-      if (reconnectRequired && !this.fullReconnectOnNext) {
         this.fullReconnectOnNext = true;
-        requireSignalEvents = true;
       }
 
       if (recoverable) {
-        this.handleDisconnect('reconnect', requireSignalEvents, ReconnectReason.REASON_UNKOWN);
+        this.handleDisconnect('reconnect', ReconnectReason.REASON_UNKOWN);
       } else {
         log.info(
           `could not recover connection after ${this.reconnectAttempts} attempts, ${
@@ -810,16 +801,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     return null;
   }
 
-  private async restartConnection(emitRestarting: boolean = false) {
+  private async restartConnection() {
     if (!this.url || !this.token) {
       // permanent failure, don't attempt reconnection
       throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
     }
 
     log.info(`reconnecting, attempt: ${this.reconnectAttempts}`);
-    if (emitRestarting || this.reconnectAttempts === 0) {
-      this.emit(EngineEvent.Restarting);
-    }
+    this.emit(EngineEvent.Restarting);
 
     if (this.client.isConnected) {
       await this.client.sendLeave();
@@ -842,6 +831,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       throw new SignalReconnectError();
     }
 
+    if (this.shouldFailNext) {
+      this.shouldFailNext = false;
+      throw new Error('simulated failure');
+    }
+
     await this.waitForPCConnected();
     this.client.setReconnected();
 
@@ -849,10 +843,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.emit(EngineEvent.Restarted, joinResponse);
   }
 
-  private async resumeConnection(
-    emitResuming: boolean = false,
-    reason?: ReconnectReason,
-  ): Promise<void> {
+  private async resumeConnection(reason?: ReconnectReason): Promise<void> {
     if (!this.url || !this.token) {
       // permanent failure, don't attempt reconnection
       throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -863,9 +854,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     log.info(`resuming signal connection, attempt ${this.reconnectAttempts}`);
-    if (emitResuming || this.reconnectAttempts === 0) {
-      this.emit(EngineEvent.Resuming);
-    }
+    this.emit(EngineEvent.Resuming);
 
     try {
       const res = await this.client.reconnect(this.url, this.token, this.participantSid, reason);
@@ -883,6 +872,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
     this.emit(EngineEvent.SignalResumed);
 
+    if (this.shouldFailNext) {
+      this.shouldFailNext = false;
+      throw new Error('simulated failure');
+    }
+
     this.subscriber.restartingIce = true;
 
     // only restart publisher if it's needed
@@ -921,11 +915,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.primaryPC?.connectionState === 'connected'
       ) {
         this.pcState = PCState.Connected;
-        try {
-          this.connectedServerAddr = await getConnectedAddress(this.primaryPC);
-        } catch (e) {
-          log.warn('could not get connected server address', { error: e });
-        }
       }
       if (this.pcState === PCState.Connected) {
         return;
@@ -1022,7 +1011,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
       const negotiationTimeout = setTimeout(() => {
         reject('negotiation timed out');
-        this.handleDisconnect('negotiation', false, ReconnectReason.REASON_SIGNAL_DISCONNECTED);
+        this.handleDisconnect('negotiation', ReconnectReason.REASON_SIGNAL_DISCONNECTED);
       }, this.peerConnectionTimeout);
 
       const cleanup = () => {
@@ -1043,7 +1032,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         if (e instanceof NegotiationError) {
           this.fullReconnectOnNext = true;
         }
-        this.handleDisconnect('negotiation', false, ReconnectReason.REASON_UNKOWN);
+        this.handleDisconnect('negotiation', ReconnectReason.REASON_UNKOWN);
       });
     });
   }
@@ -1066,6 +1055,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
   }
 
+  /* @internal */
+  failNext() {
+    // debugging method to fail the next reconnect/resume attempt
+    this.shouldFailNext = true;
+  }
+
   private clearReconnectTimeout() {
     if (this.reconnectTimeout) {
       CriticalTimers.clearTimeout(this.reconnectTimeout);
@@ -1081,7 +1076,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     // in case the engine is currently reconnecting, attempt a reconnect immediately after the browser state has changed to 'onLine'
     if (this.client.isReconnecting) {
       this.clearReconnectTimeout();
-      this.attemptReconnect(true, ReconnectReason.REASON_SIGNAL_DISCONNECTED);
+      this.attemptReconnect(ReconnectReason.REASON_SIGNAL_DISCONNECTED);
     }
   };
 

package/src/room/Room.ts

@@ -56,8 +56,8 @@ import type { AdaptiveStreamSettings } from './track/types';
 import { getNewAudioContext } from './track/utils';
 import type { SimulationOptions } from './types';
 import {
-  Future,
   createDummyVideoStreamTrack,
+  Future,
   getEmptyAudioStreamTrack,
   isWeb,
   Mutex,
@@ -516,6 +516,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<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');
+        }
+        break;
       case 'force-tcp':
       case 'force-tls':
         req = SimulateScenario.fromPartial({
@@ -786,6 +793,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
             });
             await track.restartTrack();
           }
+          log.debug('publishing new track', {
+            track: pub.trackSid,
+          });
           await this.localParticipant.publishTrack(track, pub.options);
         }
       }),
@@ -886,7 +896,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     participant.tracks.forEach((publication) => {
       participant.unpublishTrack(publication.trackSid, true);
     });
-    this.emitWhenConnected(RoomEvent.ParticipantDisconnected, participant);
+    this.emit(RoomEvent.ParticipantDisconnected, participant);
   }
 
   // updates are sent only when there's a change to speaker ordering
@@ -1114,7 +1124,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         },
       )
       .on(ParticipantEvent.TrackUnpublished, (publication: RemoteTrackPublication) => {
-        this.emitWhenConnected(RoomEvent.TrackUnpublished, publication, participant);
+        this.emit(RoomEvent.TrackUnpublished, publication, participant);
       })
       .on(
         ParticipantEvent.TrackUnsubscribed,

package/src/room/events.ts

@@ -252,7 +252,8 @@ export enum RoomEvent {
   SignalConnected = 'signalConnected',
 
   /**
-   * Recording of a room has started/stopped.
+   * Recording of a room has started/stopped. Room.isRecording will be updated too.
+   * args: (isRecording: boolean)
    */
   RecordingStatusChanged = 'recordingStatusChanged',
 }

package/src/room/participant/LocalParticipant.ts

@@ -439,7 +439,13 @@ export default class LocalParticipant extends Participant {
           `Opus DTX will be disabled for stereo tracks by default. Enable them explicitly to make it work.`,
         );
       }
+      if (options.red === undefined) {
+        log.info(
+          `Opus RED will be disabled for stereo tracks by default. Enable them explicitly to make it work.`,
+        );
+      }
       options.dtx ??= false;
+      options.red ??= false;
     }
     const opts: TrackPublishOptions = {
       ...this.roomOptions.publishDefaults,
@@ -721,17 +727,24 @@ export default class LocalParticipant extends Participant {
       track.stop();
     }
 
+    let negotiationNeeded = false;
+    const trackSender = track.sender;
+    track.sender = undefined;
     if (
       this.engine.publisher &&
       this.engine.publisher.pc.connectionState !== 'closed' &&
-      track.sender
+      trackSender
     ) {
       try {
-        this.engine.removeTrack(track.sender);
+        if (this.engine.removeTrack(trackSender)) {
+          negotiationNeeded = true;
+        }
         if (track instanceof LocalVideoTrack) {
           for (const [, trackInfo] of track.simulcastCodecs) {
             if (trackInfo.sender) {
-              this.engine.removeTrack(trackInfo.sender);
+              if (this.engine.removeTrack(trackInfo.sender)) {
+                negotiationNeeded = true;
+              }
               trackInfo.sender = undefined;
             }
           }
@@ -739,13 +752,9 @@ export default class LocalParticipant extends Participant {
         }
       } catch (e) {
         log.warn('failed to unpublish track', { error: e, method: 'unpublishTrack' });
-      } finally {
-        await this.engine.negotiate();
       }
     }
 
-    track.sender = undefined;
-
     // remove from our maps
     this.tracks.delete(publication.trackSid);
     switch (publication.kind) {
@@ -762,6 +771,9 @@ export default class LocalParticipant extends Participant {
     this.emit(ParticipantEvent.LocalTrackUnpublished, publication);
     publication.setTrack(undefined);
 
+    if (negotiationNeeded) {
+      await this.engine.negotiate();
+    }
     return publication;
   }
 
@@ -957,7 +969,7 @@ export default class LocalParticipant extends Participant {
         }
       }
     } else if (update.subscribedQualities.length > 0) {
-      pub.videoTrack?.setPublishingLayers(update.subscribedQualities);
+      await pub.videoTrack?.setPublishingLayers(update.subscribedQualities);
     }
   };
 

package/src/room/participant/RemoteParticipant.ts

@@ -236,8 +236,7 @@ export default class RemoteParticipant extends Participant {
         }
         publication = new RemoteTrackPublication(
           kind,
-          ti.sid,
-          ti.name,
+          ti,
           this.signalClient.connectOptions?.autoSubscribe,
         );
         publication.updateInfo(ti);
@@ -246,7 +245,7 @@ export default class RemoteParticipant extends Participant {
           (publishedTrack) => publishedTrack.source === publication?.source,
         );
         if (existingTrackOfSource && publication.source !== Track.Source.Unknown) {
-          log.warn(
+          log.debug(
             `received a second track publication for ${this.identity} with the same source: ${publication.source}`,
             {
               oldTrack: existingTrackOfSource,

package/src/room/track/LocalVideoTrack.ts

@@ -3,7 +3,7 @@ import log from '../../logger';
 import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
 import type { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc';
 import { computeBitrate, monitorFrequency, VideoSenderStats } from '../stats';
-import { isFireFox, isMobile, isWeb } from '../utils';
+import { isFireFox, isMobile, isWeb, Mutex } from '../utils';
 import LocalTrack from './LocalTrack';
 import type { VideoCaptureOptions, VideoCodec } from './options';
 import { Track } from './Track';
@@ -39,6 +39,12 @@ export default class LocalVideoTrack extends LocalTrack {
 
   private subscribedCodecs?: SubscribedCodec[];
 
+  // prevents concurrent manipulations to track sender
+  // if multiple get/setParameter are called concurrently, certain timing of events
+  // could lead to the browser throwing an exception in `setParameter`, due to
+  // a missing `getParameter` call.
+  private senderLock: Mutex;
+
   /**
    *
    * @param mediaTrack
@@ -51,6 +57,7 @@ export default class LocalVideoTrack extends LocalTrack {
     userProvidedTrack = true,
   ) {
     super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack);
+    this.senderLock = new Mutex();
   }
 
   get isSimulcast(): boolean {
@@ -257,6 +264,7 @@ export default class LocalVideoTrack extends LocalTrack {
             simulcastCodecInfo.sender,
             simulcastCodecInfo.encodings!,
             codec.qualities,
+            this.senderLock,
           );
         }
       }
@@ -274,7 +282,7 @@ export default class LocalVideoTrack extends LocalTrack {
       return;
     }
 
-    await setPublishingLayersForSender(this.sender, this.encodings, qualities);
+    await setPublishingLayersForSender(this.sender, this.encodings, qualities, this.senderLock);
   }
 
   protected monitorSender = async () => {
@@ -317,58 +325,66 @@ async function setPublishingLayersForSender(
   sender: RTCRtpSender,
   senderEncodings: RTCRtpEncodingParameters[],
   qualities: SubscribedQuality[],
+  senderLock: Mutex,
 ) {
+  const unlock = await senderLock.lock();
   log.debug('setPublishingLayersForSender', { sender, qualities, senderEncodings });
-  const params = sender.getParameters();
-  const { encodings } = params;
-  if (!encodings) {
-    return;
-  }
-
-  if (encodings.length !== senderEncodings.length) {
-    log.warn('cannot set publishing layers, encodings mismatch');
-    return;
-  }
-
-  let hasChanged = false;
-  encodings.forEach((encoding, idx) => {
-    let rid = encoding.rid ?? '';
-    if (rid === '') {
-      rid = 'q';
+  try {
+    const params = sender.getParameters();
+    const { encodings } = params;
+    if (!encodings) {
+      return;
     }
-    const quality = videoQualityForRid(rid);
-    const subscribedQuality = qualities.find((q) => q.quality === quality);
-    if (!subscribedQuality) {
+
+    if (encodings.length !== senderEncodings.length) {
+      log.warn('cannot set publishing layers, encodings mismatch');
       return;
     }
-    if (encoding.active !== subscribedQuality.enabled) {
-      hasChanged = true;
-      encoding.active = subscribedQuality.enabled;
-      log.debug(
-        `setting layer ${subscribedQuality.quality} to ${encoding.active ? 'enabled' : 'disabled'}`,
-      );
-
-      // FireFox does not support setting encoding.active to false, so we
-      // have a workaround of lowering its bitrate and resolution to the min.
-      if (isFireFox()) {
-        if (subscribedQuality.enabled) {
-          encoding.scaleResolutionDownBy = senderEncodings[idx].scaleResolutionDownBy;
-          encoding.maxBitrate = senderEncodings[idx].maxBitrate;
-          /* @ts-ignore */
-          encoding.maxFrameRate = senderEncodings[idx].maxFrameRate;
-        } else {
-          encoding.scaleResolutionDownBy = 4;
-          encoding.maxBitrate = 10;
-          /* @ts-ignore */
-          encoding.maxFrameRate = 2;
+
+    let hasChanged = false;
+    encodings.forEach((encoding, idx) => {
+      let rid = encoding.rid ?? '';
+      if (rid === '') {
+        rid = 'q';
+      }
+      const quality = videoQualityForRid(rid);
+      const subscribedQuality = qualities.find((q) => q.quality === quality);
+      if (!subscribedQuality) {
+        return;
+      }
+      if (encoding.active !== subscribedQuality.enabled) {
+        hasChanged = true;
+        encoding.active = subscribedQuality.enabled;
+        log.debug(
+          `setting layer ${subscribedQuality.quality} to ${
+            encoding.active ? 'enabled' : 'disabled'
+          }`,
+        );
+
+        // FireFox does not support setting encoding.active to false, so we
+        // have a workaround of lowering its bitrate and resolution to the min.
+        if (isFireFox()) {
+          if (subscribedQuality.enabled) {
+            encoding.scaleResolutionDownBy = senderEncodings[idx].scaleResolutionDownBy;
+            encoding.maxBitrate = senderEncodings[idx].maxBitrate;
+            /* @ts-ignore */
+            encoding.maxFrameRate = senderEncodings[idx].maxFrameRate;
+          } else {
+            encoding.scaleResolutionDownBy = 4;
+            encoding.maxBitrate = 10;
+            /* @ts-ignore */
+            encoding.maxFrameRate = 2;
+          }
         }
       }
-    }
-  });
+    });
 
-  if (hasChanged) {
-    params.encodings = encodings;
-    await sender.setParameters(params);
+    if (hasChanged) {
+      params.encodings = encodings;
+      await sender.setParameters(params);
+    }
+  } finally {
+    unlock();
   }
 }
 

package/src/room/track/RemoteTrackPublication.ts

@@ -24,9 +24,10 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   protected fps?: number;
 
-  constructor(kind: Track.Kind, id: string, name: string, autoSubscribe: boolean | undefined) {
-    super(kind, id, name);
+  constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined) {
+    super(kind, ti.sid, ti.name);
     this.subscribed = autoSubscribe;
+    this.updateInfo(ti);
   }
 
   /**

package/src/room/track/RemoteVideoTrack.ts

@@ -31,9 +31,6 @@ export default class RemoteVideoTrack extends RemoteTrack {
   ) {
     super(mediaTrack, sid, Track.Kind.Video, receiver);
     this.adaptiveStreamSettings = adaptiveStreamSettings;
-    if (this.isAdaptiveStream) {
-      this.streamState = Track.StreamState.Paused;
-    }
   }
 
   get isAdaptiveStream(): boolean {

package/src/room/track/Track.ts

@@ -32,7 +32,8 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
   mediaStream?: MediaStream;
 
   /**
-   * indicates current state of stream
+   * indicates current state of stream, it'll indicate `paused` if the track
+   * has been paused by congestion controller
    */
   streamState: Track.StreamState = Track.StreamState.Active;
 

package/src/room/track/options.ts

@@ -28,12 +28,12 @@ export interface TrackPublishDefaults {
   audioBitrate?: number;
 
   /**
-   * dtx (Discontinuous Transmission of audio), defaults to true
+   * dtx (Discontinuous Transmission of audio), enabled by default for mono tracks.
    */
   dtx?: boolean;
 
   /**
-   * red (Redundant Audio Data), defaults to true
+   * red (Redundant Audio Data), enabled by default for mono tracks.
    */
   red?: boolean;