livekit-client 1.6.0 → 1.6.2

package/src/room/Room.ts

@@ -239,14 +239,19 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     await fetch(`http${url.substring(2)}`, { method: 'HEAD' });
   }
 
-  connect = (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
+  connect = async (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
+    // In case a disconnect called happened right before the connect call, make sure the disconnect is completed first by awaiting its lock
+    const unlockDisconnect = await this.disconnectLock.lock();
+
     if (this.state === ConnectionState.Connected) {
       // when the state is reconnecting or connected, this function returns immediately
       log.info(`already connected to room ${this.name}`);
+      unlockDisconnect();
       return Promise.resolve();
     }
 
     if (this.connectFuture) {
+      unlockDisconnect();
       return this.connectFuture.promise;
     }
 
@@ -256,6 +261,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       if (!this.abortController || this.abortController.signal.aborted) {
         this.abortController = new AbortController();
       }
+      // at this point the intention to connect has been signalled so we can allow cancelling of the connection via disconnect() again
+      unlockDisconnect();
 
       if (this.state === ConnectionState.Reconnecting) {
         log.info('Reconnection attempt replaced by new connection attempt');
@@ -556,7 +563,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     });
 
     try {
-      await Promise.all(elements.map((e) => e.play()));
+      await Promise.all(
+        elements.map((e) => {
+          e.muted = false;
+          return e.play();
+        }),
+      );
       this.handleAudioPlaybackStarted();
     } catch (err) {
       this.handleAudioPlaybackFailed(err);
@@ -1045,6 +1057,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (this.options.expWebAudioMix) {
       this.participants.forEach((participant) => participant.setAudioContext(this.audioContext));
     }
+
+    const newContextIsRunning = this.audioContext?.state === 'running';
+    if (newContextIsRunning !== this.canPlaybackAudio) {
+      this.audioEnabled = newContextIsRunning;
+      this.emit(RoomEvent.AudioPlaybackStatusChanged, newContextIsRunning);
+    }
   }
 
   private createParticipant(id: string, info?: ParticipantInfo): RemoteParticipant {
@@ -1263,10 +1281,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * No actual connection to a server will be established, all state is
    * @experimental
    */
-  simulateParticipants(options: SimulationOptions) {
+  async simulateParticipants(options: SimulationOptions) {
     const publishOptions = {
       audio: true,
       video: true,
+      useRealTracks: false,
       ...options.publish,
     };
     const participantOptions = {
@@ -1278,8 +1297,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     };
     this.handleDisconnect();
     this.name = 'simulated-room';
-    this.localParticipant.identity = 'simulated-local';
-    this.localParticipant.name = 'simulated-local';
+
+    this.localParticipant.updateInfo(
+      ParticipantInfo.fromPartial({
+        identity: 'simulated-local',
+        name: 'local-name',
+      }),
+    );
     this.setupLocalParticipantEvents();
     this.emit(RoomEvent.SignalConnected);
     this.emit(RoomEvent.Connected);
@@ -1294,12 +1318,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           name: 'video-dummy',
         }),
         new LocalVideoTrack(
-          createDummyVideoStreamTrack(
-            160 * participantOptions.aspectRatios[0] ?? 1,
-            160,
-            true,
-            true,
-          ),
+          publishOptions.useRealTracks
+            ? (await navigator.mediaDevices.getUserMedia({ video: true })).getVideoTracks()[0]
+            : createDummyVideoStreamTrack(
+                160 * participantOptions.aspectRatios[0] ?? 1,
+                160,
+                true,
+                true,
+              ),
         ),
       );
       // @ts-ignore
@@ -1314,7 +1340,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           sid: Math.floor(Math.random() * 10_000).toString(),
           type: TrackType.AUDIO,
         }),
-        new LocalAudioTrack(getEmptyAudioStreamTrack()),
+        new LocalAudioTrack(
+          publishOptions.useRealTracks
+            ? (await navigator.mediaDevices.getUserMedia({ audio: true })).getAudioTracks()[0]
+            : getEmptyAudioStreamTrack(),
+        ),
       );
       // @ts-ignore
       this.localParticipant.addTrackPublication(audioPub);

package/src/room/events.ts

@@ -418,6 +418,7 @@ export enum EngineEvent {
   Restarting = 'restarting',
   Restarted = 'restarted',
   SignalResumed = 'signalResumed',
+  Closing = 'closing',
   MediaTrackAdded = 'mediaTrackAdded',
   ActiveSpeakersUpdate = 'activeSpeakersUpdate',
   DataPacketReceived = 'dataPacketReceived',

package/src/room/participant/LocalParticipant.ts

@@ -262,7 +262,7 @@ export default class LocalParticipant extends Participant {
     } else if (track && track.track) {
       // screenshare cannot be muted, unpublish instead
       if (source === Track.Source.ScreenShare) {
-        track = this.unpublishTrack(track.track);
+        track = await this.unpublishTrack(track.track);
         const screenAudioTrack = this.getTrack(Track.Source.ScreenShareAudio);
         if (screenAudioTrack && screenAudioTrack.track) {
           this.unpublishTrack(screenAudioTrack.track);
@@ -528,13 +528,19 @@ export default class LocalParticipant extends Participant {
     let encodings: RTCRtpEncodingParameters[] | undefined;
     let simEncodings: RTCRtpEncodingParameters[] | undefined;
     if (track.kind === Track.Kind.Video) {
-      // TODO: support react native, which doesn't expose getSettings
-      const settings = track.mediaStreamTrack.getSettings();
-      const width = settings.width ?? track.dimensions?.width;
-      const height = settings.height ?? track.dimensions?.height;
+      let dims: Track.Dimensions = {
+        width: 0,
+        height: 0,
+      };
+      try {
+        dims = await track.waitForDimensions();
+      } catch (e) {
+        // log failure
+        log.error('could not determine track dimensions');
+      }
       // width and height should be defined for video
-      req.width = width ?? 0;
-      req.height = height ?? 0;
+      req.width = dims.width;
+      req.height = dims.height;
       // for svc codecs, disable simulcast and use vp8 for backup codec
       if (track instanceof LocalVideoTrack) {
         if (opts?.videoCodec === 'av1') {
@@ -565,8 +571,8 @@ export default class LocalParticipant extends Participant {
 
       encodings = computeVideoEncodings(
         track.source === Track.Source.ScreenShare,
-        width,
-        height,
+        dims.width,
+        dims.height,
         opts,
       );
       req.layers = videoLayersFromEncodings(req.width, req.height, simEncodings ?? encodings);
@@ -694,10 +700,10 @@ export default class LocalParticipant extends Participant {
     log.debug(`published ${videoCodec} for track ${track.sid}`, { encodings, trackInfo: ti });
   }
 
-  unpublishTrack(
+  async unpublishTrack(
     track: LocalTrack | MediaStreamTrack,
     stopOnUnpublish?: boolean,
-  ): LocalTrackPublication | undefined {
+  ): Promise<LocalTrackPublication | undefined> {
     // look through all published tracks to find the right ones
     const publication = this.getPublicationForTrack(track);
 
@@ -744,7 +750,7 @@ export default class LocalParticipant extends Participant {
       } catch (e) {
         log.warn('failed to unpublish track', { error: e, method: 'unpublishTrack' });
       } finally {
-        this.engine.negotiate();
+        await this.engine.negotiate();
       }
     }
 
@@ -769,15 +775,33 @@ export default class LocalParticipant extends Participant {
     return publication;
   }
 
-  unpublishTracks(tracks: LocalTrack[] | MediaStreamTrack[]): LocalTrackPublication[] {
-    const publications: LocalTrackPublication[] = [];
-    tracks.forEach((track: LocalTrack | MediaStreamTrack) => {
-      const pub = this.unpublishTrack(track);
-      if (pub) {
-        publications.push(pub);
+  async unpublishTracks(
+    tracks: LocalTrack[] | MediaStreamTrack[],
+  ): Promise<LocalTrackPublication[]> {
+    const results = await Promise.all(tracks.map((track) => this.unpublishTrack(track)));
+    return results.filter(
+      (track) => track instanceof LocalTrackPublication,
+    ) as LocalTrackPublication[];
+  }
+
+  async republishAllTracks(options?: TrackPublishOptions) {
+    const localPubs: LocalTrackPublication[] = [];
+    this.tracks.forEach((pub) => {
+      if (pub.track) {
+        if (options) {
+          pub.options = { ...pub.options, ...options };
+        }
+        localPubs.push(pub);
       }
     });
-    return publications;
+
+    await Promise.all(
+      localPubs.map(async (pub) => {
+        const track = pub.track!;
+        await this.unpublishTrack(track, false);
+        await this.publishTrack(track, pub.options);
+      }),
+    );
   }
 
   /**

package/src/room/participant/RemoteParticipant.ts

@@ -263,11 +263,6 @@ export default class RemoteParticipant extends Participant {
       validTracks.set(ti.sid, publication);
     });
 
-    // always emit events for new publications, Room will not forward them unless it's ready
-    newTracks.forEach((publication) => {
-      this.emit(ParticipantEvent.TrackPublished, publication);
-    });
-
     // detect removed tracks
     this.tracks.forEach((publication) => {
       if (!validTracks.has(publication.trackSid)) {
@@ -278,6 +273,11 @@ export default class RemoteParticipant extends Participant {
         this.unpublishTrack(publication.trackSid, true);
       }
     });
+
+    // always emit events for new publications, Room will not forward them unless it's ready
+    newTracks.forEach((publication) => {
+      this.emit(ParticipantEvent.TrackPublished, publication);
+    });
   }
 
   /** @internal */

package/src/room/track/LocalTrack.ts

@@ -3,10 +3,12 @@ import log from '../../logger';
 import DeviceManager from '../DeviceManager';
 import { TrackInvalidError } from '../errors';
 import { TrackEvent } from '../events';
-import { getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isMobile } from '../utils';
+import { getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isMobile, sleep } from '../utils';
 import type { VideoCodec } from './options';
 import { attachToElement, detachTrack, Track } from './Track';
 
+const defaultDimensionsTimeout = 2 * 1000;
+
 export default abstract class LocalTrack extends Track {
   /** @internal */
   sender?: RTCRtpSender;
@@ -72,6 +74,22 @@ export default abstract class LocalTrack extends Track {
     return this.providedByUser;
   }
 
+  async waitForDimensions(timeout = defaultDimensionsTimeout): Promise<Track.Dimensions> {
+    if (this.kind === Track.Kind.Audio) {
+      throw new Error('cannot get dimensions for audio tracks');
+    }
+
+    const started = Date.now();
+    while (Date.now() - started < timeout) {
+      const dims = this.dimensions;
+      if (dims) {
+        return dims;
+      }
+      await sleep(50);
+    }
+    throw new TrackInvalidError('unable to get track dimensions after timeout');
+  }
+
   /**
    * @returns DeviceID of the device that is currently being used for this track
    */

package/src/room/track/Track.ts

@@ -121,7 +121,9 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
     // we'll want to re-attach it in that case
     attachToElement(this._mediaStreamTrack, element);
 
-    if (element instanceof HTMLAudioElement) {
+    // handle auto playback failures
+    const allMediaStreamTracks = (element.srcObject as MediaStream).getTracks();
+    if (allMediaStreamTracks.some((tr) => tr.kind === 'audio')) {
       // manually play audio to detect audio playback status
       element
         .play()
@@ -130,6 +132,17 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
         })
         .catch((e) => {
           this.emit(TrackEvent.AudioPlaybackFailed, e);
+          // If audio playback isn't allowed make sure we still play back the video
+          if (
+            element &&
+            allMediaStreamTracks.some((tr) => tr.kind === 'video') &&
+            e.name === 'NotAllowedError'
+          ) {
+            element.muted = true;
+            element.play().catch(() => {
+              // catch for Safari, exceeded options at this point to automatically play the media element
+            });
+          }
         });
     }
 
@@ -259,6 +272,13 @@ export function attachToElement(track: MediaStreamTrack, element: HTMLMediaEleme
     mediaStream.addTrack(track);
   }
 
+  element.autoplay = true;
+  // In case there are no audio tracks present on the mediastream, we set the element as muted to ensure autoplay works
+  element.muted = mediaStream.getAudioTracks().length === 0;
+  if (element instanceof HTMLVideoElement) {
+    element.playsInline = true;
+  }
+
   // avoid flicker
   if (element.srcObject !== mediaStream) {
     element.srcObject = mediaStream;
@@ -280,10 +300,6 @@ export function attachToElement(track: MediaStreamTrack, element: HTMLMediaEleme
       }, 0);
     }
   }
-  element.autoplay = true;
-  if (element instanceof HTMLVideoElement) {
-    element.playsInline = true;
-  }
 }
 
 /** @internal */

package/src/room/types.ts

@@ -2,6 +2,7 @@ export type SimulationOptions = {
   publish?: {
     audio?: boolean;
     video?: boolean;
+    useRealTracks?: boolean;
   };
   participants?: {
     count?: number;