livekit-client 1.2.3 → 1.2.6

package/src/room/Room.ts

@@ -99,8 +99,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** used for aborting pending connections to a LiveKit server */
   private abortController?: AbortController;
 
+  /** future holding client initiated connection attempt */
   private connectFuture?: Future<void>;
 
+  /** future holding sdk initiated reconnection attempt */
+  private reconnectFuture?: Future<void>;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -156,12 +160,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
       .on(EngineEvent.Resuming, () => {
+        if (!this.reconnectFuture) {
+          this.reconnectFuture = new Future();
+        }
         if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
           this.emit(RoomEvent.Reconnecting);
         }
       })
       .on(EngineEvent.Resumed, () => {
         this.setAndEmitConnectionState(ConnectionState.Connected);
+        this.reconnectFuture?.resolve();
+        this.reconnectFuture = undefined;
         this.emit(RoomEvent.Reconnected);
         this.updateSubscriptions();
       })
@@ -193,145 +202,144 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return DeviceManager.getInstance().getDevices(kind, requestPermissions);
   }
 
-  connect = async (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
+  connect = (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
     if (this.state === ConnectionState.Connected) {
       // when the state is reconnecting or connected, this function returns immediately
       log.warn(`already connected to room ${this.name}`);
-      return;
+      return Promise.resolve();
     }
 
     if (this.connectFuture) {
       return this.connectFuture.promise;
+    } else if (this.reconnectFuture) {
+      this.connectFuture = this.reconnectFuture;
+      return this.connectFuture.promise;
     }
-    this.setAndEmitConnectionState(ConnectionState.Connecting);
+    const connectPromise = new Promise<void>(async (resolve, reject) => {
+      this.setAndEmitConnectionState(ConnectionState.Connecting);
+      if (!this.abortController || this.abortController.signal.aborted) {
+        this.abortController = new AbortController();
+      }
 
-    if (!this.abortController || this.abortController.signal.aborted) {
-      this.abortController = new AbortController();
-    }
+      // recreate engine if previously disconnected
+      this.createEngine();
 
-    // recreate engine if previously disconnected
-    this.createEngine();
+      this.acquireAudioContext();
 
-    this.acquireAudioContext();
+      if (opts?.rtcConfig) {
+        this.engine.rtcConfig = opts.rtcConfig;
+      }
 
-    if (opts?.rtcConfig) {
-      this.engine.rtcConfig = opts.rtcConfig;
-    }
+      this.connOptions = opts;
+
+      try {
+        const joinResponse = await this.engine.join(
+          url,
+          token,
+          {
+            autoSubscribe: opts?.autoSubscribe,
+            publishOnly: opts?.publishOnly,
+            adaptiveStream:
+              typeof this.options?.adaptiveStream === 'object'
+                ? true
+                : this.options?.adaptiveStream,
+          },
+          this.abortController.signal,
+        );
+        log.debug(
+          `connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`,
+        );
 
-    this.connOptions = opts;
+        if (!joinResponse.serverVersion) {
+          throw new UnsupportedServer('unknown server version');
+        }
 
-    try {
-      const joinResponse = await this.engine.join(
-        url,
-        token,
-        {
-          autoSubscribe: opts?.autoSubscribe,
-          publishOnly: opts?.publishOnly,
-          adaptiveStream:
-            typeof this.options?.adaptiveStream === 'object' ? true : this.options?.adaptiveStream,
-        },
-        this.abortController.signal,
-      );
-      log.debug(
-        `connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`,
-      );
+        if (joinResponse.serverVersion === '0.15.1' && this.options.dynacast) {
+          log.debug('disabling dynacast due to server version');
+          // dynacast has a bug in 0.15.1, so we cannot use it then
+          this.options.dynacast = false;
+        }
 
-      if (!joinResponse.serverVersion) {
-        throw new UnsupportedServer('unknown server version');
-      }
+        const pi = joinResponse.participant!;
+
+        this.localParticipant.sid = pi.sid;
+        this.localParticipant.identity = pi.identity;
+
+        this.localParticipant.updateInfo(pi);
+        // forward metadata changed for the local participant
+        this.localParticipant
+          .on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+          .on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
+          .on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
+          .on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
+          .on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
+          .on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
+          .on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
+          .on(
+            ParticipantEvent.ParticipantPermissionsChanged,
+            this.onLocalParticipantPermissionsChanged,
+          );
 
-      if (joinResponse.serverVersion === '0.15.1' && this.options.dynacast) {
-        log.debug('disabling dynacast due to server version');
-        // dynacast has a bug in 0.15.1, so we cannot use it then
-        this.options.dynacast = false;
-      }
+        // populate remote participants, these should not trigger new events
+        joinResponse.otherParticipants.forEach((info) => {
+          if (
+            info.sid !== this.localParticipant.sid &&
+            info.identity !== this.localParticipant.identity
+          ) {
+            this.getOrCreateParticipant(info.sid, info);
+          } else {
+            log.warn('received info to create local participant as remote participant', {
+              info,
+              localParticipant: this.localParticipant,
+            });
+          }
+        });
 
-      const pi = joinResponse.participant!;
-
-      this.localParticipant.sid = pi.sid;
-      this.localParticipant.identity = pi.identity;
-
-      this.localParticipant.updateInfo(pi);
-      // forward metadata changed for the local participant
-      this.localParticipant
-        .on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
-        .on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
-        .on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
-        .on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
-        .on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
-        .on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
-        .on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
-        .on(
-          ParticipantEvent.ParticipantPermissionsChanged,
-          this.onLocalParticipantPermissionsChanged,
-        );
+        this.name = joinResponse.room!.name;
+        this.sid = joinResponse.room!.sid;
+        this.metadata = joinResponse.room!.metadata;
+        this.emit(RoomEvent.SignalConnected);
+      } catch (err) {
+        this.recreateEngine();
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
+        reject(new ConnectionError('could not establish signal connection'));
+        return;
+      }
 
-      // populate remote participants, these should not trigger new events
-      joinResponse.otherParticipants.forEach((info) => {
-        if (
-          info.sid !== this.localParticipant.sid &&
-          info.identity !== this.localParticipant.identity
-        ) {
-          this.getOrCreateParticipant(info.sid, info);
-        } else {
-          log.warn('received info to create local participant as remote participant', {
-            info,
-            localParticipant: this.localParticipant,
-          });
+      // don't return until ICE connected
+      const connectTimeout = setTimeout(() => {
+        // timeout
+        this.recreateEngine();
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
+        reject(new ConnectionError('could not connect PeerConnection after timeout'));
+      }, maxICEConnectTimeout);
+      const abortHandler = () => {
+        log.warn('closing engine');
+        clearTimeout(connectTimeout);
+        this.recreateEngine();
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
+        reject(new ConnectionError('room connection has been cancelled'));
+      };
+      if (this.abortController?.signal.aborted) {
+        abortHandler();
+      }
+      this.abortController?.signal.addEventListener('abort', abortHandler);
+
+      this.engine.once(EngineEvent.Connected, () => {
+        clearTimeout(connectTimeout);
+        this.abortController?.signal.removeEventListener('abort', abortHandler);
+        // also hook unload event
+        if (isWeb()) {
+          window.addEventListener('beforeunload', this.onBeforeUnload);
+          navigator.mediaDevices?.addEventListener('devicechange', this.handleDeviceChange);
         }
+        this.setAndEmitConnectionState(ConnectionState.Connected);
+        resolve();
       });
+    }).finally(() => (this.connectFuture = undefined));
+    this.connectFuture = new Future(connectPromise);
 
-      this.name = joinResponse.room!.name;
-      this.sid = joinResponse.room!.sid;
-      this.metadata = joinResponse.room!.metadata;
-      this.emit(RoomEvent.SignalConnected);
-    } catch (err) {
-      this.recreateEngine();
-      this.setAndEmitConnectionState(
-        ConnectionState.Disconnected,
-        new ConnectionError('could not establish signal connection'),
-      );
-      throw err;
-    }
-
-    // don't return until ICE connected
-    const connectTimeout = setTimeout(() => {
-      // timeout
-      this.recreateEngine();
-      this.setAndEmitConnectionState(
-        ConnectionState.Disconnected,
-        new ConnectionError('could not connect PeerConnection after timeout'),
-      );
-    }, maxICEConnectTimeout);
-    const abortHandler = () => {
-      log.warn('closing engine');
-      clearTimeout(connectTimeout);
-      this.recreateEngine();
-      this.setAndEmitConnectionState(
-        ConnectionState.Disconnected,
-        new ConnectionError('room connection has been cancelled'),
-      );
-    };
-    if (this.abortController?.signal.aborted) {
-      abortHandler();
-    }
-    this.abortController?.signal.addEventListener('abort', abortHandler);
-
-    this.engine.once(EngineEvent.Connected, () => {
-      clearTimeout(connectTimeout);
-      this.abortController?.signal.removeEventListener('abort', abortHandler);
-      // also hook unload event
-      if (isWeb()) {
-        window.addEventListener('beforeunload', this.onBeforeUnload);
-        navigator.mediaDevices?.addEventListener('devicechange', this.handleDeviceChange);
-      }
-      this.setAndEmitConnectionState(ConnectionState.Connected);
-    });
-
-    if (this.connectFuture) {
-      /** @ts-ignore */
-      return this.connectFuture.promise;
-    }
+    return this.connectFuture.promise;
   };
 
   /**
@@ -339,11 +347,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    */
   disconnect = async (stopTracks = true) => {
     log.info('disconnect from room', { identity: this.localParticipant.identity });
-    if (this.state === ConnectionState.Connecting) {
+    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
       // try aborting pending connection attempt
       log.warn('abort connection attempt');
       this.abortController?.abort();
-      return;
+      // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
+      this.connectFuture?.reject(new ConnectionError('Client initiated disconnect'));
+      this.connectFuture = undefined;
     }
     // send leave
     if (this.engine?.client.isConnected) {
@@ -353,7 +363,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (this.engine) {
       this.engine.close();
     }
-
     this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
     /* @ts-ignore */
     this.engine = undefined;
@@ -532,8 +541,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // at that time, ICE connectivity has not been established so the track is not
     // technically subscribed.
     // We'll defer these events until when the room is connected or eventually disconnected.
-    if (this.connectFuture) {
-      this.connectFuture.promise.then(() => {
+    if (this.connectFuture || this.reconnectFuture) {
+      Promise.allSettled([this.connectFuture?.promise, this.reconnectFuture?.promise]).then(() => {
         this.onTrackAdded(mediaTrack, stream, receiver);
       });
       return;
@@ -571,6 +580,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private handleRestarting = () => {
+    if (!this.reconnectFuture) {
+      this.reconnectFuture = new Future();
+    }
     // also unwind existing participants & existing subscriptions
     for (const p of this.participants.values()) {
       this.handleParticipantDisconnected(p.sid, p);
@@ -587,6 +599,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     });
     this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Reconnected);
+    this.reconnectFuture?.resolve();
+    this.reconnectFuture = undefined;
 
     // rehydrate participants
     if (joinResponse.participant) {
@@ -630,6 +644,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (this.state === ConnectionState.Disconnected) {
       return;
     }
+    // reject potentially ongoing reconnection attempt
+    if (this.connectFuture === this.reconnectFuture) {
+      this.connectFuture?.reject(undefined);
+      this.connectFuture = undefined;
+      this.reconnectFuture = undefined;
+    }
+
     this.participants.forEach((p) => {
       p.tracks.forEach((pub) => {
         p.unpublishTrack(pub.trackSid);
@@ -704,10 +725,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       // when it's disconnected, send updates
       if (info.state === ParticipantInfo_State.DISCONNECTED) {
         this.handleParticipantDisconnected(info.sid, remoteParticipant);
-      } else if (isNewParticipant) {
-        // fire connected event
-        this.emitWhenConnected(RoomEvent.ParticipantConnected, remoteParticipant);
-      } else {
+      } else if (!isNewParticipant) {
         // just update, no events
         remoteParticipant.updateInfo(info);
       }
@@ -907,6 +925,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.participants.set(id, participant);
     if (info) {
       this.identityToSid.set(info.identity, info.sid);
+      // if we have valid info and the participant wasn't in the map before, we can assume the participant is new
+      // firing here to make sure that `ParticipantConnected` fires before the initial track events
+      this.emitWhenConnected(RoomEvent.ParticipantConnected, participant);
     }
 
     // also forward events
@@ -1030,35 +1051,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
-  private setAndEmitConnectionState(state: ConnectionState, error?: Error): boolean {
+  private setAndEmitConnectionState(state: ConnectionState): boolean {
     if (state === this.state) {
       // unchanged
       return false;
     }
-    switch (state) {
-      case ConnectionState.Connecting:
-      case ConnectionState.Reconnecting:
-        if (!this.connectFuture) {
-          // reuse existing connect future if possible
-          this.connectFuture = new Future<void>();
-        }
-        break;
-      case ConnectionState.Connected:
-        if (this.connectFuture) {
-          this.connectFuture.resolve();
-          this.connectFuture = undefined;
-        }
-        break;
-      case ConnectionState.Disconnected:
-        if (this.connectFuture) {
-          error ??= new Error('disconnected from Room');
-          this.connectFuture.reject(error);
-          this.connectFuture = undefined;
-        }
-        break;
-      default:
-      // nothing
-    }
     this.state = state;
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
     return true;

package/src/room/participant/LocalParticipant.ts

@@ -722,10 +722,20 @@ export default class LocalParticipant extends Participant {
       track.sender
     ) {
       try {
-        this.engine.publisher.pc.removeTrack(track.sender);
-        this.engine.negotiate();
+        this.engine.removeTrack(track.sender);
+        if (track instanceof LocalVideoTrack) {
+          for (const [, trackInfo] of track.simulcastCodecs) {
+            if (trackInfo.sender) {
+              this.engine.removeTrack(trackInfo.sender);
+              trackInfo.sender = undefined;
+            }
+          }
+          track.simulcastCodecs.clear();
+        }
       } catch (e) {
-        log.warn('failed to remove track', { error: e, method: 'unpublishTrack' });
+        log.warn('failed to unpublish track', { error: e, method: 'unpublishTrack' });
+      } finally {
+        this.engine.negotiate();
       }
     }
 

package/src/room/participant/RemoteParticipant.ts

@@ -210,6 +210,20 @@ export default class RemoteParticipant extends Participant {
         publication = new RemoteTrackPublication(kind, ti.sid, ti.name);
         publication.updateInfo(ti);
         newTracks.set(ti.sid, publication);
+        const existingTrackOfSource = Array.from(this.tracks.values()).find(
+          (publishedTrack) => publishedTrack.source === publication?.source,
+        );
+        if (existingTrackOfSource) {
+          log.warn(
+            `received a second track publication for ${this.identity} with the same source: ${publication.source}`,
+            {
+              oldTrack: existingTrackOfSource,
+              newTrack: publication,
+              participant: this,
+              participantInfo: info,
+            },
+          );
+        }
         this.addTrackPublication(publication);
       } else {
         publication.updateInfo(ti);
@@ -220,19 +234,6 @@ export default class RemoteParticipant extends Participant {
     // always emit events for new publications, Room will not forward them unless it's ready
     newTracks.forEach((publication) => {
       this.emit(ParticipantEvent.TrackPublished, publication);
-      const existingTrackOfSource = Array.from(this.tracks.values()).find(
-        (publishedTrack) => publishedTrack.source === publication.source,
-      );
-      if (existingTrackOfSource) {
-        log.warn(
-          `received a second track publication for ${this.identity} with the same source: ${publication.source}`,
-          {
-            oldTrack: existingTrackOfSource,
-            newTrack: publication,
-            participant: this,
-          },
-        );
-      }
     });
 
     // detect removed tracks

package/src/room/track/LocalAudioTrack.ts

@@ -8,8 +8,6 @@ import { Track } from './Track';
 import { constraintsForOptions, detectSilence } from './utils';
 
 export default class LocalAudioTrack extends LocalTrack {
-  sender?: RTCRtpSender;
-
   /** @internal */
   stopOnMute: boolean = false;
 

package/src/room/track/LocalVideoTrack.ts

@@ -27,17 +27,15 @@ export class SimulcastTrackInfo {
 const refreshSubscribedCodecAfterNewCodec = 5000;
 
 export default class LocalVideoTrack extends LocalTrack {
-  /* internal */
+  /* @internal */
   signalClient?: SignalClient;
 
   private prevStats?: Map<string, VideoSenderStats>;
 
   private encodings?: RTCRtpEncodingParameters[];
 
-  private simulcastCodecs: Map<VideoCodec, SimulcastTrackInfo> = new Map<
-    VideoCodec,
-    SimulcastTrackInfo
-  >();
+  /* @internal */
+  simulcastCodecs: Map<VideoCodec, SimulcastTrackInfo> = new Map<VideoCodec, SimulcastTrackInfo>();
 
   private subscribedCodecs?: SubscribedCodec[];
 
@@ -78,9 +76,7 @@ export default class LocalVideoTrack extends LocalTrack {
     this._mediaStreamTrack.getConstraints();
     this.simulcastCodecs.forEach((trackInfo) => {
       trackInfo.mediaStreamTrack.stop();
-      trackInfo.sender = undefined;
     });
-    this.simulcastCodecs.clear();
     super.stop();
   }
 

package/src/room/track/RemoteTrackPublication.ts

@@ -8,7 +8,7 @@ import { TrackPublication } from './TrackPublication';
 import { RemoteTrack } from './types';
 
 export default class RemoteTrackPublication extends TrackPublication {
-  track?: RemoteTrack;
+  track?: RemoteTrack = undefined;
 
   /** @internal */
   protected allowed = true;

package/src/room/track/RemoteVideoTrack.ts

@@ -10,9 +10,6 @@ import { AdaptiveStreamSettings } from './types';
 const REACTION_DELAY = 100;
 
 export default class RemoteVideoTrack extends RemoteTrack {
-  /** @internal */
-  receiver?: RTCRtpReceiver;
-
   private prevStats?: VideoReceiverStats;
 
   private elementInfos: ElementInfo[] = [];

package/src/room/track/create.ts

@@ -1,3 +1,4 @@
+import DeviceManager from '../DeviceManager';
 import { TrackInvalidError } from '../errors';
 import { mediaTrackToLocalTrack } from '../participant/publishUtils';
 import { audioDefaults, videoDefaults } from './defaults';
@@ -30,7 +31,21 @@ export async function createLocalTracks(
 
   const opts = mergeDefaultOptions(options, audioDefaults, videoDefaults);
   const constraints = constraintsForOptions(opts);
-  const stream = await navigator.mediaDevices.getUserMedia(constraints);
+
+  // Keep a reference to the promise on DeviceManager and await it in getLocalDevices()
+  // works around iOS Safari Bug https://bugs.webkit.org/show_bug.cgi?id=179363
+  const mediaPromise = navigator.mediaDevices.getUserMedia(constraints);
+
+  if (options.audio) {
+    DeviceManager.userMediaPromiseMap.set('audioinput', mediaPromise);
+    mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('audioinput'));
+  }
+  if (options.video) {
+    DeviceManager.userMediaPromiseMap.set('videoinput', mediaPromise);
+    mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('videoinput'));
+  }
+
+  const stream = await mediaPromise;
   return stream.getTracks().map((mediaStreamTrack) => {
     const isAudio = mediaStreamTrack.kind === 'audio';
     let trackOptions = isAudio ? options!.audio : options!.video;

package/src/room/utils.ts

@@ -122,10 +122,12 @@ export class Future<T> {
 
   reject!: (e: any) => void;
 
-  constructor() {
-    this.promise = new Promise<T>((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
+  constructor(promise?: Promise<T>) {
+    this.promise =
+      promise ??
+      new Promise<T>((resolve, reject) => {
+        this.resolve = resolve;
+        this.reject = reject;
+      });
   }
 }