livekit-client 1.4.4 → 1.6.0

package/src/connectionHelper/ConnectionCheck.ts

@@ -0,0 +1,90 @@
+import EventEmitter from 'events';
+import type TypedEmitter from 'typed-emitter';
+
+import { Checker, CheckInfo, CheckStatus, InstantiableCheck } from './checks/Checker';
+import { PublishAudioCheck } from './checks/publishAudio';
+import { PublishVideoCheck } from './checks/publishVideo';
+import { ReconnectCheck } from './checks/reconnect';
+import { TURNCheck } from './checks/turn';
+import { WebRTCCheck } from './checks/webrtc';
+import { WebSocketCheck } from './checks/websocket';
+
+export type { CheckInfo };
+
+export class ConnectionCheck extends (EventEmitter as new () => TypedEmitter<ConnectionCheckCallbacks>) {
+  token: string;
+
+  url: string;
+
+  private checkResults: Map<number, CheckInfo> = new Map();
+
+  constructor(url: string, token: string) {
+    super();
+    this.url = url;
+    this.token = token;
+  }
+
+  private getNextCheckId() {
+    const nextId = this.checkResults.size;
+    this.checkResults.set(nextId, {
+      logs: [],
+      status: CheckStatus.IDLE,
+      name: '',
+      description: '',
+    });
+    return nextId;
+  }
+
+  private updateCheck(checkId: number, info: CheckInfo) {
+    this.checkResults.set(checkId, info);
+    this.emit('checkUpdate', checkId, info);
+  }
+
+  isSuccess() {
+    return Array.from(this.checkResults.values()).every((r) => r.status !== CheckStatus.FAILED);
+  }
+
+  getResults() {
+    return Array.from(this.checkResults.values());
+  }
+
+  async createAndRunCheck<T extends Checker>(check: InstantiableCheck<T>) {
+    const checkId = this.getNextCheckId();
+    const test = new check(this.url, this.token);
+    const handleUpdate = (info: CheckInfo) => {
+      this.updateCheck(checkId, info);
+    };
+    test.on('update', handleUpdate);
+    const result = await test.run();
+    test.off('update', handleUpdate);
+    return result;
+  }
+
+  async checkWebsocket() {
+    return this.createAndRunCheck(WebSocketCheck);
+  }
+
+  async checkWebRTC() {
+    return this.createAndRunCheck(WebRTCCheck);
+  }
+
+  async checkTURN() {
+    return this.createAndRunCheck(TURNCheck);
+  }
+
+  async checkReconnect() {
+    return this.createAndRunCheck(ReconnectCheck);
+  }
+
+  async checkPublishAudio() {
+    return this.createAndRunCheck(PublishAudioCheck);
+  }
+
+  async checkPublishVideo() {
+    return this.createAndRunCheck(PublishVideoCheck);
+  }
+}
+
+type ConnectionCheckCallbacks = {
+  checkUpdate: (id: number, info: CheckInfo) => void;
+};

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.');
+    }
+    await 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}.`);
+    await 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,
@@ -22,8 +23,11 @@ import {
   supportsAdaptiveStream,
   supportsAV1,
   supportsDynacast,
+  createAudioAnalyser,
 } from './room/utils';
 
+import type { AudioAnalyserOptions } from './room/utils';
+
 export * from './options';
 export * from './room/errors';
 export * from './room/events';
@@ -32,6 +36,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,
@@ -41,6 +46,8 @@ export {
   supportsAdaptiveStream,
   supportsDynacast,
   supportsAV1,
+  createAudioAnalyser,
+  AudioAnalyserOptions,
   LogLevel,
   Room,
   ConnectionState,

package/src/options.ts

@@ -7,6 +7,10 @@ import type {
 } from './room/track/options';
 import type { AdaptiveStreamSettings } from './room/track/types';
 
+export interface WebAudioSettings {
+  audioContext: AudioContext;
+}
+
 /**
  * @internal
  */
@@ -72,7 +76,7 @@ export interface InternalRoomOptions {
    * experimental flag, mix all audio tracks in web audio
    */
 
-  expWebAudioMix: boolean;
+  expWebAudioMix: boolean | WebAudioSettings;
 }
 
 /**

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;
   }