livekit-client 1.5.0 → 1.6.1

package/src/room/Room.ts

@@ -17,6 +17,9 @@ import {
   Room as RoomModel,
   ServerInfo,
   SpeakerInfo,
+  TrackInfo,
+  TrackSource,
+  TrackType,
   UserPacket,
 } from '../proto/livekit_models';
 import {
@@ -42,7 +45,7 @@ import type { ConnectionQuality } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
 import RTCEngine from './RTCEngine';
 import LocalAudioTrack from './track/LocalAudioTrack';
-import type LocalTrackPublication from './track/LocalTrackPublication';
+import LocalTrackPublication from './track/LocalTrackPublication';
 import LocalVideoTrack from './track/LocalVideoTrack';
 import type RemoteTrack from './track/RemoteTrack';
 import RemoteTrackPublication from './track/RemoteTrackPublication';
@@ -50,7 +53,16 @@ import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
 import type { AdaptiveStreamSettings } from './track/types';
 import { getNewAudioContext } from './track/utils';
-import { Future, isWeb, supportsSetSinkId, unpackStreamId } from './utils';
+import type { SimulationOptions } from './types';
+import {
+  Future,
+  createDummyVideoStreamTrack,
+  getEmptyAudioStreamTrack,
+  isWeb,
+  Mutex,
+  supportsSetSinkId,
+  unpackStreamId,
+} from './utils';
 
 export enum ConnectionState {
   Disconnected = 'disconnected',
@@ -118,6 +130,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** future holding client initiated connection attempt */
   private connectFuture?: Future<void>;
 
+  private disconnectLock: Mutex;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -144,6 +158,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     this.maybeCreateEngine();
 
+    this.disconnectLock = new Mutex();
+
     this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
   }
 
@@ -223,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;
     }
 
@@ -240,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');
@@ -303,18 +326,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
         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.setupLocalParticipantEvents();
 
         // populate remote participants, these should not trigger new events
         joinResponse.otherParticipants.forEach((info) => {
@@ -342,7 +354,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       } catch (err) {
         this.recreateEngine();
         this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
-        reject(new ConnectionError('could not establish signal connection'));
+        let errorMessage = '';
+        if (err instanceof Error) {
+          errorMessage = err.message;
+          log.debug(`error trying to establish signal connection`, { error: err });
+        }
+        reject(new ConnectionError(`could not establish signal connection: ${errorMessage}`));
         return;
       }
 
@@ -389,26 +406,38 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * disconnects the room, emits [[RoomEvent.Disconnected]]
    */
   disconnect = async (stopTracks = true) => {
-    log.info('disconnect from room', { identity: this.localParticipant.identity });
-    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
-      // try aborting pending connection attempt
-      log.warn('abort connection attempt');
-      this.abortController?.abort();
-      // 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) {
-      await this.engine.client.sendLeave();
-    }
-    // close engine (also closes client)
-    if (this.engine) {
-      this.engine.close();
+    const unlock = await this.disconnectLock.lock();
+    try {
+      if (this.state === ConnectionState.Disconnected) {
+        log.debug('already disconnected');
+        return;
+      }
+      log.info('disconnect from room', { identity: this.localParticipant.identity });
+      if (
+        this.state === ConnectionState.Connecting ||
+        this.state === ConnectionState.Reconnecting
+      ) {
+        // try aborting pending connection attempt
+        log.warn('abort connection attempt');
+        this.abortController?.abort();
+        // 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) {
+        await this.engine.client.sendLeave();
+      }
+      // close engine (also closes client)
+      if (this.engine) {
+        await this.engine.close();
+      }
+      this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
+      /* @ts-ignore */
+      this.engine = undefined;
+    } finally {
+      unlock();
     }
-    this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
-    /* @ts-ignore */
-    this.engine = undefined;
   };
 
   /**
@@ -440,12 +469,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /**
    * @internal for testing
    */
-  simulateScenario(scenario: string) {
+  async simulateScenario(scenario: string) {
     let postAction = () => {};
     let req: SimulateScenario | undefined;
     switch (scenario) {
       case 'signal-reconnect':
-        this.engine.client.close();
+        await this.engine.client.close();
         if (this.engine.client.onClose) {
           this.engine.client.onClose('simulate disconnect');
         }
@@ -508,8 +537,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
-  private onBeforeUnload = () => {
-    this.disconnect();
+  private onBeforeUnload = async () => {
+    await this.disconnect();
   };
 
   /**
@@ -520,7 +549,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * - `getUserMedia`
    */
   async startAudio() {
-    this.acquireAudioContext();
+    await this.acquireAudioContext();
 
     const elements: Array<HTMLMediaElement> = [];
     this.participants.forEach((p) => {
@@ -534,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);
@@ -550,7 +584,18 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   /**
-   * Switches all active device used in this room to the given device.
+   * Returns the active audio output device used in this room.
+   *
+   * Note: to get the active `audioinput` or `videoinput` use [[LocalTrack.getDeviceId()]]
+   *
+   * @return the previously successfully set audio output device ID or an empty string if the default device is used.
+   */
+  getActiveAudioOutputDevice(): string {
+    return this.options.audioOutput?.deviceId ?? '';
+  }
+
+  /**
+   * Switches all active devices used in this room to the given device.
    *
    * Note: setting AudioOutput is not supported on some browsers. See [setSinkId](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId#browser_compatibility)
    *
@@ -592,16 +637,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.options.audioOutput ??= {};
       const prevDeviceId = this.options.audioOutput.deviceId;
       this.options.audioOutput.deviceId = deviceId;
-      const promises: Promise<void>[] = [];
-      this.participants.forEach((p) => {
-        promises.push(
-          p.setAudioOutput({
-            deviceId,
-          }),
-        );
-      });
       try {
-        await Promise.all(promises);
+        await Promise.all(
+          Array.from(this.participants.values()).map((p) => p.setAudioOutput({ deviceId })),
+        );
       } catch (e) {
         this.options.audioOutput.deviceId = prevDeviceId;
         throw e;
@@ -609,6 +648,21 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
+  private setupLocalParticipantEvents() {
+    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,
+      );
+  }
+
   private recreateEngine() {
     this.engine?.close();
     /* @ts-ignore */
@@ -773,7 +827,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     this.participants.clear();
     this.activeSpeakers = [];
-    if (this.audioContext) {
+    if (this.audioContext && typeof this.options.expWebAudioMix === 'boolean') {
       this.audioContext.close();
       this.audioContext = undefined;
     }
@@ -986,18 +1040,28 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     });
   };
 
-  private acquireAudioContext() {
-    if (this.audioContext) {
-      this.audioContext.close();
+  private async acquireAudioContext() {
+    if (
+      typeof this.options.expWebAudioMix !== 'boolean' &&
+      this.options.expWebAudioMix.audioContext
+    ) {
+      // override audio context with custom audio context if supplied by user
+      this.audioContext = this.options.expWebAudioMix.audioContext;
+      await this.audioContext.resume();
+    } else {
+      // by using an AudioContext, it reduces lag on audio elements
+      // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
+      this.audioContext = getNewAudioContext() ?? undefined;
     }
-    // by using an AudioContext, it reduces lag on audio elements
-    // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
-    const ctx = getNewAudioContext();
-    if (ctx) {
-      this.audioContext = ctx;
-      if (this.options.expWebAudioMix) {
-        this.participants.forEach((participant) => participant.setAudioContext(this.audioContext));
-      }
+
+    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);
     }
   }
 
@@ -1212,6 +1276,113 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
   };
 
+  /**
+   * Allows to populate a room with simulated participants.
+   * No actual connection to a server will be established, all state is
+   * @experimental
+   */
+  simulateParticipants(options: SimulationOptions) {
+    const publishOptions = {
+      audio: true,
+      video: true,
+      ...options.publish,
+    };
+    const participantOptions = {
+      count: 9,
+      audio: false,
+      video: true,
+      aspectRatios: [1.66, 1.7, 1.3],
+      ...options.participants,
+    };
+    this.handleDisconnect();
+    this.name = 'simulated-room';
+
+    this.localParticipant.updateInfo(
+      ParticipantInfo.fromPartial({
+        identity: 'simulated-local',
+        name: 'local-name',
+      }),
+    );
+    this.setupLocalParticipantEvents();
+    this.emit(RoomEvent.SignalConnected);
+    this.emit(RoomEvent.Connected);
+    this.setAndEmitConnectionState(ConnectionState.Connected);
+    if (publishOptions.video) {
+      const camPub = new LocalTrackPublication(
+        Track.Kind.Video,
+        TrackInfo.fromPartial({
+          source: TrackSource.CAMERA,
+          sid: Math.floor(Math.random() * 10_000).toString(),
+          type: TrackType.AUDIO,
+          name: 'video-dummy',
+        }),
+        new LocalVideoTrack(
+          createDummyVideoStreamTrack(
+            160 * participantOptions.aspectRatios[0] ?? 1,
+            160,
+            true,
+            true,
+          ),
+        ),
+      );
+      // @ts-ignore
+      this.localParticipant.addTrackPublication(camPub);
+      this.localParticipant.emit(ParticipantEvent.LocalTrackPublished, camPub);
+    }
+    if (publishOptions.audio) {
+      const audioPub = new LocalTrackPublication(
+        Track.Kind.Audio,
+        TrackInfo.fromPartial({
+          source: TrackSource.MICROPHONE,
+          sid: Math.floor(Math.random() * 10_000).toString(),
+          type: TrackType.AUDIO,
+        }),
+        new LocalAudioTrack(getEmptyAudioStreamTrack()),
+      );
+      // @ts-ignore
+      this.localParticipant.addTrackPublication(audioPub);
+      this.localParticipant.emit(ParticipantEvent.LocalTrackPublished, audioPub);
+    }
+
+    for (let i = 0; i < participantOptions.count - 1; i += 1) {
+      let info: ParticipantInfo = ParticipantInfo.fromPartial({
+        sid: Math.floor(Math.random() * 10_000).toString(),
+        identity: `simulated-${i}`,
+        state: ParticipantInfo_State.ACTIVE,
+        tracks: [],
+        joinedAt: Date.now(),
+      });
+      const p = this.getOrCreateParticipant(info.identity, info);
+      if (participantOptions.video) {
+        const dummyVideo = createDummyVideoStreamTrack(
+          160 * participantOptions.aspectRatios[i % participantOptions.aspectRatios.length] ?? 1,
+          160,
+          false,
+          true,
+        );
+        const videoTrack = TrackInfo.fromPartial({
+          source: TrackSource.CAMERA,
+          sid: Math.floor(Math.random() * 10_000).toString(),
+          type: TrackType.AUDIO,
+        });
+        p.addSubscribedMediaTrack(dummyVideo, videoTrack.sid, new MediaStream([dummyVideo]));
+        info.tracks = [...info.tracks, videoTrack];
+      }
+      if (participantOptions.audio) {
+        const dummyTrack = getEmptyAudioStreamTrack();
+        const audioTrack = TrackInfo.fromPartial({
+          source: TrackSource.MICROPHONE,
+          sid: Math.floor(Math.random() * 10_000).toString(),
+          type: TrackType.AUDIO,
+        });
+        p.addSubscribedMediaTrack(dummyTrack, audioTrack.sid, new MediaStream([dummyTrack]));
+        info.tracks = [...info.tracks, audioTrack];
+      }
+
+      p.updateInfo(info);
+    }
+  }
+
   // /** @internal */
   emit<E extends keyof RoomEventCallbacks>(
     event: E,

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',
@@ -427,6 +428,10 @@ export enum TrackEvent {
   Message = 'message',
   Muted = 'muted',
   Unmuted = 'unmuted',
+  /**
+   * Only fires on LocalTracks
+   */
+  Restarted = 'restarted',
   Ended = 'ended',
   Subscribed = 'subscribed',
   Unsubscribed = 'unsubscribed',

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);
+      }),
+    );
   }
 
   /**
@@ -964,7 +988,7 @@ export default class LocalParticipant extends Participant {
       });
       this.unpublishTrack(track);
     } else if (track.isUserProvided) {
-      await track.pauseUpstream();
+      await track.mute();
     } else if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
       try {
         if (isWeb()) {
@@ -993,8 +1017,8 @@ export default class LocalParticipant extends Participant {
         log.debug('track ended, attempting to use a different device');
         await track.restartTrack();
       } catch (e) {
-        log.warn(`could not restart track, pausing upstream instead`);
-        await track.pauseUpstream();
+        log.warn(`could not restart track, muting instead`);
+        await track.mute();
       }
     }
   };

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/participant/publishUtils.ts

@@ -305,7 +305,7 @@ function encodingsFromPresets(
     const rid = videoRids[idx];
     encodings.push({
       rid,
-      scaleResolutionDownBy: size / Math.min(preset.width, preset.height),
+      scaleResolutionDownBy: Math.max(1, size / Math.min(preset.width, preset.height)),
       maxBitrate: preset.encoding.maxBitrate,
       /* @ts-ignore */
       maxFramerate: preset.encoding.maxFramerate,

package/src/room/track/LocalAudioTrack.ts

@@ -114,7 +114,7 @@ export default class LocalAudioTrack extends LocalTrack {
   };
 
   async getSenderStats(): Promise<AudioSenderStats | undefined> {
-    if (!this.sender) {
+    if (!this.sender?.getStats) {
       return undefined;
     }
 

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
    */
@@ -183,6 +201,7 @@ export default abstract class LocalTrack extends Track {
 
     this.mediaStream = mediaStream;
     this.constraints = constraints;
+    this.emit(TrackEvent.Restarted, this);
     return this;
   }