livekit-client 1.4.4 → 1.5.0

package/src/connectionHelper/checks/Checker.ts

@@ -0,0 +1,164 @@
+import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
+import type { RoomConnectOptions, RoomOptions } from '../../options';
+import Room, { ConnectionState } from '../../room/Room';
+import type RTCEngine from '../../room/RTCEngine';
+
+type LogMessage = {
+  level: 'info' | 'warning' | 'error';
+  message: string;
+};
+
+export enum CheckStatus {
+  IDLE,
+  RUNNING,
+  SKIPPED,
+  SUCCESS,
+  FAILED,
+}
+
+export type CheckInfo = {
+  name: string;
+  logs: Array<LogMessage>;
+  status: CheckStatus;
+  description: string;
+};
+
+export interface CheckerOptions {
+  errorsAsWarnings?: boolean;
+  roomOptions?: RoomOptions;
+  connectOptions?: RoomConnectOptions;
+}
+
+export abstract class Checker extends (EventEmitter as new () => TypedEmitter<CheckerCallbacks>) {
+  protected url: string;
+
+  protected token: string;
+
+  room: Room;
+
+  connectOptions?: RoomConnectOptions;
+
+  status: CheckStatus = CheckStatus.IDLE;
+
+  logs: Array<LogMessage> = [];
+
+  errorsAsWarnings: boolean = false;
+
+  name: string;
+
+  constructor(url: string, token: string, options: CheckerOptions = {}) {
+    super();
+    this.url = url;
+    this.token = token;
+    this.name = this.constructor.name;
+    this.room = new Room(options.roomOptions);
+    this.connectOptions = options.connectOptions;
+    if (options.errorsAsWarnings) {
+      this.errorsAsWarnings = options.errorsAsWarnings;
+    }
+  }
+
+  abstract get description(): string;
+
+  protected abstract perform(): Promise<void>;
+
+  async run(onComplete?: () => void) {
+    if (this.status !== CheckStatus.IDLE) {
+      throw Error('check is running already');
+    }
+    this.setStatus(CheckStatus.RUNNING);
+    this.appendMessage(`${this.name} started.`);
+
+    try {
+      await this.perform();
+    } catch (err) {
+      if (err instanceof Error) {
+        if (this.errorsAsWarnings) {
+          this.appendWarning(err.message);
+        } else {
+          this.appendError(err.message);
+        }
+      }
+    }
+
+    await this.disconnect();
+
+    // sleep for a bit to ensure disconnect
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // @ts-ignore
+    if (this.status !== CheckStatus.SKIPPED) {
+      this.setStatus(this.isSuccess() ? CheckStatus.SUCCESS : CheckStatus.FAILED);
+    }
+
+    if (onComplete) {
+      onComplete();
+    }
+    return this.getInfo();
+  }
+
+  protected isSuccess(): boolean {
+    return !this.logs.some((l) => l.level === 'error');
+  }
+
+  protected async connect(): Promise<Room> {
+    if (this.room.state === ConnectionState.Connected) {
+      return this.room;
+    }
+    await this.room.connect(this.url, this.token);
+    return this.room;
+  }
+
+  protected async disconnect() {
+    if (this.room && this.room.state !== ConnectionState.Disconnected) {
+      await this.room.disconnect();
+      // wait for it to go through
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+  }
+
+  protected skip() {
+    this.setStatus(CheckStatus.SKIPPED);
+  }
+
+  protected appendMessage(message: string) {
+    this.logs.push({ level: 'info', message });
+    this.emit('update', this.getInfo());
+  }
+
+  protected appendWarning(message: string) {
+    this.logs.push({ level: 'warning', message });
+    this.emit('update', this.getInfo());
+  }
+
+  protected appendError(message: string) {
+    this.logs.push({ level: 'error', message });
+    this.emit('update', this.getInfo());
+  }
+
+  protected setStatus(status: CheckStatus) {
+    this.status = status;
+    this.emit('update', this.getInfo());
+  }
+
+  protected get engine(): RTCEngine | undefined {
+    return this.room?.engine;
+  }
+
+  getInfo(): CheckInfo {
+    return {
+      logs: this.logs,
+      name: this.name,
+      status: this.status,
+      description: this.description,
+    };
+  }
+}
+export type InstantiableCheck<T extends Checker> = {
+  new (url: string, token: string, options?: CheckerOptions): T;
+};
+
+type CheckerCallbacks = {
+  update: (info: CheckInfo) => void;
+};

package/src/connectionHelper/checks/publishAudio.ts

@@ -0,0 +1,33 @@
+import { createLocalAudioTrack } from '../../room/track/create';
+import { Checker } from './Checker';
+
+export class PublishAudioCheck extends Checker {
+  get description(): string {
+    return 'Can publish audio';
+  }
+
+  async perform(): Promise<void> {
+    const room = await this.connect();
+
+    const track = await createLocalAudioTrack();
+    room.localParticipant.publishTrack(track);
+    // wait for a few seconds to publish
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+
+    // verify RTC stats that it's publishing
+    const stats = await track.sender?.getStats();
+    if (!stats) {
+      throw new Error('Could not get RTCStats');
+    }
+    let numPackets = 0;
+    stats.forEach((stat) => {
+      if (stat.type === 'outbound-rtp' && stat.mediaType === 'audio') {
+        numPackets = stat.packetsSent;
+      }
+    });
+    if (numPackets === 0) {
+      throw new Error('Could not determine packets are sent');
+    }
+    this.appendMessage(`published ${numPackets} audio packets`);
+  }
+}

package/src/connectionHelper/checks/publishVideo.ts

@@ -0,0 +1,33 @@
+import { createLocalVideoTrack } from '../../room/track/create';
+import { Checker } from './Checker';
+
+export class PublishVideoCheck extends Checker {
+  get description(): string {
+    return 'Can publish video';
+  }
+
+  async perform(): Promise<void> {
+    const room = await this.connect();
+
+    const track = await createLocalVideoTrack();
+    room.localParticipant.publishTrack(track);
+    // wait for a few seconds to publish
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+
+    // verify RTC stats that it's publishing
+    const stats = await track.sender?.getStats();
+    if (!stats) {
+      throw new Error('Could not get RTCStats');
+    }
+    let numPackets = 0;
+    stats.forEach((stat) => {
+      if (stat.type === 'outbound-rtp' && stat.mediaType === 'video') {
+        numPackets = stat.packetsSent;
+      }
+    });
+    if (numPackets === 0) {
+      throw new Error('Could not determine packets are sent');
+    }
+    this.appendMessage(`published ${numPackets} video packets`);
+  }
+}

package/src/connectionHelper/checks/reconnect.ts

@@ -0,0 +1,45 @@
+import { RoomEvent } from '../../room/events';
+import { ConnectionState } from '../../room/Room';
+import { Checker } from './Checker';
+
+export class ReconnectCheck extends Checker {
+  get description(): string {
+    return 'Resuming connection after interruption';
+  }
+
+  async perform(): Promise<void> {
+    const room = await this.connect();
+    let reconnectingTriggered = false;
+    let reconnected = false;
+
+    let reconnectResolver: (value: unknown) => void;
+    const reconnectTimeout = new Promise((resolve) => {
+      setTimeout(resolve, 5000);
+      reconnectResolver = resolve;
+    });
+
+    room
+      .on(RoomEvent.Reconnecting, () => {
+        reconnectingTriggered = true;
+      })
+      .on(RoomEvent.Reconnected, () => {
+        reconnected = true;
+        reconnectResolver(true);
+      });
+
+    room.engine.client.ws?.close();
+    const onClose = room.engine.client.onClose;
+    if (onClose) {
+      onClose('');
+    }
+
+    await reconnectTimeout;
+
+    if (!reconnectingTriggered) {
+      throw new Error('Did not attempt to reconnect');
+    } else if (!reconnected || room.state !== ConnectionState.Connected) {
+      this.appendWarning('reconnection is only possible in Redis-based configurations');
+      throw new Error('Not able to reconnect');
+    }
+  }
+}

package/src/connectionHelper/checks/turn.ts

@@ -0,0 +1,53 @@
+import { SignalClient } from '../../api/SignalClient';
+import { Checker } from './Checker';
+
+export class TURNCheck extends Checker {
+  get description(): string {
+    return 'Can connect via TURN';
+  }
+
+  async perform(): Promise<void> {
+    const signalClient = new SignalClient();
+    const joinRes = await signalClient.join(this.url, this.token, {
+      autoSubscribe: true,
+      maxRetries: 0,
+    });
+
+    let hasTLS = false;
+    let hasTURN = false;
+    let hasSTUN = false;
+
+    for (let iceServer of joinRes.iceServers) {
+      for (let url of iceServer.urls) {
+        if (url.startsWith('turn:')) {
+          hasTURN = true;
+          hasSTUN = true;
+        } else if (url.startsWith('turns:')) {
+          hasTURN = true;
+          hasSTUN = true;
+          hasTLS = true;
+        }
+        if (url.startsWith('stun:')) {
+          hasSTUN = true;
+        }
+      }
+    }
+    if (!hasSTUN) {
+      this.appendWarning('No STUN servers configured on server side.');
+    } else if (hasTURN && !hasTLS) {
+      this.appendWarning('TURN is configured server side, but TURN/TLS is unavailable.');
+    }
+    signalClient.close();
+    if (this.connectOptions?.rtcConfig?.iceServers || hasTURN) {
+      await this.room!.connect(this.url, this.token, {
+        rtcConfig: {
+          iceTransportPolicy: 'relay',
+        },
+      });
+    } else {
+      this.appendWarning('No TURN servers configured.');
+      this.skip();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+}

package/src/connectionHelper/checks/webrtc.ts

@@ -0,0 +1,18 @@
+import { Checker } from './Checker';
+
+export class WebRTCCheck extends Checker {
+  get description(): string {
+    return 'Establishing WebRTC connection';
+  }
+
+  protected async perform(): Promise<void> {
+    try {
+      console.log('initiating room connection');
+      this.room = await this.connect();
+      console.log('now the room is connected');
+    } catch (err) {
+      this.appendWarning('ports need to be open on firewall in order to connect.');
+      throw err;
+    }
+  }
+}

package/src/connectionHelper/checks/websocket.ts

@@ -0,0 +1,22 @@
+import { SignalClient } from '../../api/SignalClient';
+import { Checker } from './Checker';
+
+export class WebSocketCheck extends Checker {
+  get description(): string {
+    return 'Connecting to signal connection via WebSocket';
+  }
+
+  protected async perform(): Promise<void> {
+    if (this.url.startsWith('ws:') || this.url.startsWith('http:')) {
+      this.appendWarning('Server is insecure, clients may block connections to it');
+    }
+
+    let signalClient = new SignalClient();
+    const joinRes = await signalClient.join(this.url, this.token, {
+      autoSubscribe: true,
+      maxRetries: 0,
+    });
+    this.appendMessage(`Connected to server, version ${joinRes.serverVersion}.`);
+    signalClient.close();
+  }
+}

package/src/index.ts

@@ -13,7 +13,8 @@ import LocalVideoTrack from './room/track/LocalVideoTrack';
 import RemoteAudioTrack from './room/track/RemoteAudioTrack';
 import RemoteTrack from './room/track/RemoteTrack';
 import RemoteTrackPublication from './room/track/RemoteTrackPublication';
-import RemoteVideoTrack, { type ElementInfo } from './room/track/RemoteVideoTrack';
+import RemoteVideoTrack from './room/track/RemoteVideoTrack';
+import type { ElementInfo } from './room/track/RemoteVideoTrack';
 import { TrackPublication } from './room/track/TrackPublication';
 import {
   getEmptyAudioStreamTrack,
@@ -32,6 +33,7 @@ export * from './room/track/options';
 export * from './room/track/Track';
 export * from './room/track/types';
 export * from './version';
+export * from './connectionHelper/ConnectionCheck';
 export {
   setLogLevel,
   setLogExtension,

package/src/proto/livekit_rtc.ts

@@ -267,6 +267,8 @@ export interface UpdateTrackSettings {
   width: number;
   /** for video, height to receive */
   height: number;
+  /** for video, frame rate to receive */
+  fps: number;
 }
 
 export interface LeaveRequest {
@@ -1843,7 +1845,7 @@ export const UpdateSubscription = {
 };
 
 function createBaseUpdateTrackSettings(): UpdateTrackSettings {
-  return { trackSids: [], disabled: false, quality: 0, width: 0, height: 0 };
+  return { trackSids: [], disabled: false, quality: 0, width: 0, height: 0, fps: 0 };
 }
 
 export const UpdateTrackSettings = {
@@ -1863,6 +1865,9 @@ export const UpdateTrackSettings = {
     if (message.height !== 0) {
       writer.uint32(48).uint32(message.height);
     }
+    if (message.fps !== 0) {
+      writer.uint32(56).uint32(message.fps);
+    }
     return writer;
   },
 
@@ -1888,6 +1893,9 @@ export const UpdateTrackSettings = {
         case 6:
           message.height = reader.uint32();
           break;
+        case 7:
+          message.fps = reader.uint32();
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1903,6 +1911,7 @@ export const UpdateTrackSettings = {
       quality: isSet(object.quality) ? videoQualityFromJSON(object.quality) : 0,
       width: isSet(object.width) ? Number(object.width) : 0,
       height: isSet(object.height) ? Number(object.height) : 0,
+      fps: isSet(object.fps) ? Number(object.fps) : 0,
     };
   },
 
@@ -1917,6 +1926,7 @@ export const UpdateTrackSettings = {
     message.quality !== undefined && (obj.quality = videoQualityToJSON(message.quality));
     message.width !== undefined && (obj.width = Math.round(message.width));
     message.height !== undefined && (obj.height = Math.round(message.height));
+    message.fps !== undefined && (obj.fps = Math.round(message.fps));
     return obj;
   },
 
@@ -1927,6 +1937,7 @@ export const UpdateTrackSettings = {
     message.quality = object.quality ?? 0;
     message.width = object.width ?? 0;
     message.height = object.height ?? 0;
+    message.fps = object.fps ?? 0;
     return message;
   },
 };

package/src/room/DeviceManager.ts

@@ -65,23 +65,6 @@ export default class DeviceManager {
       devices = devices.filter((device) => device.kind === kind);
     }
 
-    // Chrome returns 'default' devices, we would filter them out, but put the default
-    // device at first
-    // we would only do this if there are more than 1 device though
-    if (devices.length > 1 && devices[0].deviceId === defaultId) {
-      // find another device with matching group id, and move that to 0
-      const defaultDevice = devices[0];
-      for (let i = 1; i < devices.length; i += 1) {
-        if (devices[i].groupId === defaultDevice.groupId) {
-          const temp = devices[0];
-          devices[0] = devices[i];
-          devices[i] = temp;
-          break;
-        }
-      }
-      return devices.filter((device) => device !== defaultDevice);
-    }
-
     return devices;
   }
 

package/src/room/Room.ts

@@ -101,6 +101,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** options of room */
   options: InternalRoomOptions;
 
+  private _isRecording: boolean = false;
+
   private identityToSid: Map<string, string>;
 
   /** connect options of room */
@@ -332,6 +334,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.name = joinResponse.room!.name;
         this.sid = joinResponse.room!.sid;
         this.metadata = joinResponse.room!.metadata;
+        if (this._isRecording !== joinResponse.room!.activeRecording) {
+          this._isRecording = joinResponse.room!.activeRecording;
+          this.emit(RoomEvent.RecordingStatusChanged, joinResponse.room!.activeRecording);
+        }
         this.emit(RoomEvent.SignalConnected);
       } catch (err) {
         this.recreateEngine();
@@ -424,6 +430,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.connectFuture = undefined;
   }
 
+  /**
+   * if the current room has a participant with `recorder: true` in its JWT grant
+   **/
+  get isRecording() {
+    return this._isRecording;
+  }
+
   /**
    * @internal for testing
    */
@@ -950,8 +963,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleRoomUpdate = (r: RoomModel) => {
-    this.metadata = r.metadata;
-    this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
+    if (this._isRecording !== r.activeRecording) {
+      this._isRecording = r.activeRecording;
+      this.emit(RoomEvent.RecordingStatusChanged, r.activeRecording);
+    }
+    if (this.metadata !== r.metadata) {
+      this.metadata = r.metadata;
+      this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
+    }
   };
 
   private handleConnectionQualityUpdate = (update: ConnectionQualityUpdate) => {
@@ -1273,4 +1292,5 @@ export type RoomEventCallbacks = {
   ) => void;
   audioPlaybackChanged: (playing: boolean) => void;
   signalConnected: () => void;
+  recordingStatusChanged: (recording: boolean) => void;
 };

package/src/room/events.ts

@@ -250,6 +250,11 @@ export enum RoomEvent {
    * Signal connected, can publish tracks.
    */
   SignalConnected = 'signalConnected',
+
+  /**
+   * Recording of a room has started/stopped.
+   */
+  RecordingStatusChanged = 'recordingStatusChanged',
 }
 
 export enum ParticipantEvent {

package/src/room/participant/LocalParticipant.ts

@@ -34,7 +34,7 @@ import {
 } from '../track/options';
 import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
-import { isFireFox, isWeb, supportsAV1 } from '../utils';
+import { isFireFox, isSafari, isWeb, supportsAV1 } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
 import {
@@ -243,6 +243,7 @@ export default class LocalParticipant extends Participant {
           }
           const publishPromises: Array<Promise<LocalTrackPublication>> = [];
           for (const localTrack of localTracks) {
+            log.info('publishing track', { localTrack });
             publishPromises.push(this.publishTrack(localTrack, publishOptions));
           }
           const publishedTracks = await Promise.all(publishPromises);
@@ -374,14 +375,20 @@ export default class LocalParticipant extends Participant {
 
     let videoConstraints: MediaTrackConstraints | boolean = true;
     if (options.resolution) {
-      videoConstraints = {
-        width: options.resolution.width,
-        height: options.resolution.height,
-        frameRate: options.resolution.frameRate,
-      };
+      if (isSafari()) {
+        videoConstraints = {
+          width: { max: options.resolution.width },
+          height: { max: options.resolution.height },
+          frameRate: options.resolution.frameRate,
+        };
+      } else {
+        videoConstraints = {
+          width: { ideal: options.resolution.width },
+          height: { ideal: options.resolution.height },
+          frameRate: options.resolution.frameRate,
+        };
+      }
     }
-    // typescript definition is missing getDisplayMedia: https://github.com/microsoft/TypeScript/issues/33232
-    // @ts-ignore
     const stream: MediaStream = await navigator.mediaDevices.getDisplayMedia({
       audio: options.audio ?? false,
       video: videoConstraints,

package/src/room/track/LocalTrack.ts

@@ -121,6 +121,9 @@ export default abstract class LocalTrack extends Track {
     }
     this._mediaStreamTrack = track;
 
+    // sync muted state with the enabled state of the newly provided track
+    this._mediaStreamTrack.enabled = !this.isMuted;
+
     await this.resumeUpstream();
 
     this.attachedElements.forEach((el) => {

package/src/room/track/RemoteTrackPublication.ts

@@ -22,6 +22,8 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   protected videoDimensions?: Track.Dimensions;
 
+  protected fps?: number;
+
   constructor(kind: Track.Kind, id: string, name: string, autoSubscribe: boolean | undefined) {
     super(kind, id, name);
     this.subscribed = autoSubscribe;
@@ -143,6 +145,23 @@ export default class RemoteTrackPublication extends TrackPublication {
     this.emitTrackUpdate();
   }
 
+  setVideoFPS(fps: number) {
+    if (!this.isManualOperationAllowed()) {
+      return;
+    }
+
+    if (!(this.track instanceof RemoteVideoTrack)) {
+      return;
+    }
+
+    if (this.fps === fps) {
+      return;
+    }
+
+    this.fps = fps;
+    this.emitTrackUpdate();
+  }
+
   get videoQuality(): VideoQuality | undefined {
     return this.currentVideoQuality;
   }
@@ -256,6 +275,7 @@ export default class RemoteTrackPublication extends TrackPublication {
     const settings: UpdateTrackSettings = UpdateTrackSettings.fromPartial({
       trackSids: [this.trackSid],
       disabled: this.disabled,
+      fps: this.fps,
     });
     if (this.videoDimensions) {
       settings.width = this.videoDimensions.width;