livekit-client 1.6.1 → 1.6.3

package/dist/ts4.2/src/room/PCTransport.d.ts

@@ -18,6 +18,7 @@ export default class PCTransport extends EventEmitter {
     renegotiate: boolean;
     trackBitrates: TrackBitrateInfo[];
     remoteStereoMids: string[];
+    remoteNackMids: string[];
     onOffer?: (offer: RTCSessionDescriptionInit) => void;
     constructor(config?: RTCConfiguration);
     get isICEConnected(): boolean;

package/dist/ts4.2/src/room/RTCEngine.d.ts

@@ -54,6 +54,7 @@ export default class RTCEngine extends RTCEngine_base {
     get dataSubscriberReadyState(): string | undefined;
     get connectedServerAddress(): string | undefined;
     private configure;
+    private makeRTCConfiguration;
     private createDataChannels;
     private handleDataChannel;
     private handleDataMessage;
@@ -79,6 +80,7 @@ export default class RTCEngine extends RTCEngine_base {
     /** @internal */
     negotiate(): Promise<void>;
     dataChannelForKind(kind: DataPacket_Kind, sub?: boolean): RTCDataChannel | undefined;
+    private clearReconnectTimeout;
     private clearPendingReconnect;
     private handleBrowserOnLine;
     private registerOnLineListener;

package/dist/ts4.2/src/room/Room.d.ts

@@ -179,7 +179,7 @@ declare class Room extends Room_base {
      * No actual connection to a server will be established, all state is
      * @experimental
      */
-    simulateParticipants(options: SimulationOptions): void;
+    simulateParticipants(options: SimulationOptions): Promise<void>;
     emit<E extends keyof RoomEventCallbacks>(event: E, ...args: Parameters<RoomEventCallbacks[E]>): boolean;
 }
 export default Room;

package/dist/ts4.2/src/room/timers.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/**
+ * Timers that can be overridden with platform specific implementations
+ * that ensure that they are fired. These should be used when it is critical
+ * that the timer fires on time.
+ */
+export default class CriticalTimers {
+    static setTimeout: (callback: (args: void) => void, ms?: number | undefined) => NodeJS.Timeout;
+    static setInterval: (callback: (args: void) => void, ms?: number | undefined) => NodeJS.Timer;
+    static clearTimeout: (timeoutId: NodeJS.Timeout) => void;
+    static clearInterval: (intervalId: NodeJS.Timeout) => void;
+}
+//# sourceMappingURL=timers.d.ts.map

package/dist/ts4.2/src/room/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",

package/src/api/SignalClient.ts

@@ -14,6 +14,7 @@ import {
   ConnectionQualityUpdate,
   JoinResponse,
   LeaveRequest,
+  ReconnectResponse,
   SessionDescription,
   SignalRequest,
   SignalResponse,
@@ -30,6 +31,7 @@ import {
   UpdateTrackSettings,
 } from '../proto/livekit_rtc';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
+import CriticalTimers from '../room/timers';
 import { getClientInfo, Mutex, sleep } from '../room/utils';
 
 // internal options
@@ -164,7 +166,7 @@ export class SignalClient {
     return res as JoinResponse;
   }
 
-  async reconnect(url: string, token: string, sid?: string): Promise<void> {
+  async reconnect(url: string, token: string, sid?: string): Promise<ReconnectResponse | void> {
     if (!this.options) {
       log.warn('attempted to reconnect without signal options being set, ignoring');
       return;
@@ -173,7 +175,8 @@ export class SignalClient {
     // clear ping interval and restart it once reconnected
     this.clearPingInterval();
 
-    await this.connect(url, token, { ...this.options, reconnect: true, sid });
+    const res = await this.connect(url, token, { ...this.options, reconnect: true, sid });
+    return res;
   }
 
   connect(
@@ -181,7 +184,7 @@ export class SignalClient {
     token: string,
     opts: ConnectOpts,
     abortSignal?: AbortSignal,
-  ): Promise<JoinResponse | void> {
+  ): Promise<JoinResponse | ReconnectResponse | void> {
     this.connectOptions = opts;
     if (url.startsWith('http')) {
       url = url.replace('http', 'ws');
@@ -193,7 +196,7 @@ export class SignalClient {
     const clientInfo = getClientInfo();
     const params = createConnectionParams(token, clientInfo, opts);
 
-    return new Promise<JoinResponse | void>(async (resolve, reject) => {
+    return new Promise<JoinResponse | ReconnectResponse | void>(async (resolve, reject) => {
       const abortHandler = async () => {
         await this.close();
         reject(new ConnectionError('room connection has been cancelled'));
@@ -240,16 +243,6 @@ export class SignalClient {
         this.handleWSError(ev);
       };
 
-      this.ws.onopen = () => {
-        if (opts.reconnect) {
-          // upon reconnection, there will not be additional handshake
-          this.isConnected = true;
-          // restart ping interval as it's cleared for reconnection
-          this.startPingInterval();
-          resolve();
-        }
-      };
-
       this.ws.onmessage = async (ev: MessageEvent) => {
         // not considered connected until JoinResponse is received
         let resp: SignalResponse;
@@ -264,6 +257,7 @@ export class SignalClient {
         }
 
         if (!this.isConnected) {
+          let shouldProcessMessage = false;
           // handle join message only
           if (resp.message?.$case === 'join') {
             this.isConnected = true;
@@ -279,14 +273,28 @@ export class SignalClient {
               this.startPingInterval();
             }
             resolve(resp.message.join);
-          } else {
+          } else if (opts.reconnect) {
+            // in reconnecting, any message received means signal reconnected
+            this.isConnected = true;
+            abortSignal?.removeEventListener('abort', abortHandler);
+            this.startPingInterval();
+            if (resp.message?.$case === 'reconnect') {
+              resolve(resp.message?.reconnect);
+            } else {
+              resolve();
+              shouldProcessMessage = true;
+            }
+          } else if (!opts.reconnect) {
+            // non-reconnect case, should receive join response first
             reject(
               new ConnectionError(
                 `did not receive join response, got ${resp.message?.$case} instead`,
               ),
             );
           }
-          return;
+          if (!shouldProcessMessage) {
+            return;
+          }
         }
 
         if (this.signalLatency) {
@@ -576,7 +584,7 @@ export class SignalClient {
       log.warn('ping timeout duration not set');
       return;
     }
-    this.pingTimeout = setTimeout(() => {
+    this.pingTimeout = CriticalTimers.setTimeout(() => {
       log.warn(
         `ping timeout triggered. last pong received at: ${new Date(
           Date.now() - this.pingTimeoutDuration! * 1000,
@@ -590,7 +598,7 @@ export class SignalClient {
 
   private clearPingTimeout() {
     if (this.pingTimeout) {
-      clearTimeout(this.pingTimeout);
+      CriticalTimers.clearTimeout(this.pingTimeout);
     }
   }
 
@@ -602,7 +610,7 @@ export class SignalClient {
       return;
     }
     log.debug('start ping interval');
-    this.pingInterval = setInterval(() => {
+    this.pingInterval = CriticalTimers.setInterval(() => {
       this.sendPing();
     }, this.pingIntervalDuration * 1000);
   }
@@ -611,7 +619,7 @@ export class SignalClient {
     log.debug('clearing ping interval');
     this.clearPingTimeout();
     if (this.pingInterval) {
-      clearInterval(this.pingInterval);
+      CriticalTimers.clearInterval(this.pingInterval);
     }
   }
 }

package/src/index.ts

@@ -16,6 +16,7 @@ import RemoteTrackPublication from './room/track/RemoteTrackPublication';
 import RemoteVideoTrack from './room/track/RemoteVideoTrack';
 import type { ElementInfo } from './room/track/RemoteVideoTrack';
 import { TrackPublication } from './room/track/TrackPublication';
+import CriticalTimers from './room/timers';
 import {
   getEmptyAudioStreamTrack,
   getEmptyVideoStreamTrack,
@@ -71,4 +72,5 @@ export {
   ConnectionQuality,
   ElementInfo,
   DefaultReconnectPolicy,
+  CriticalTimers,
 };

package/src/proto/livekit_models.ts

@@ -386,6 +386,48 @@ export function participantInfo_StateToJSON(object: ParticipantInfo_State): stri
   }
 }
 
+export interface Encryption {
+}
+
+export enum Encryption_Type {
+  NONE = 0,
+  GCM = 1,
+  CUSTOM = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function encryption_TypeFromJSON(object: any): Encryption_Type {
+  switch (object) {
+    case 0:
+    case "NONE":
+      return Encryption_Type.NONE;
+    case 1:
+    case "GCM":
+      return Encryption_Type.GCM;
+    case 2:
+    case "CUSTOM":
+      return Encryption_Type.CUSTOM;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Encryption_Type.UNRECOGNIZED;
+  }
+}
+
+export function encryption_TypeToJSON(object: Encryption_Type): string {
+  switch (object) {
+    case Encryption_Type.NONE:
+      return "NONE";
+    case Encryption_Type.GCM:
+      return "GCM";
+    case Encryption_Type.CUSTOM:
+      return "CUSTOM";
+    case Encryption_Type.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export interface SimulcastCodecInfo {
   mimeType: string;
   mid: string;
@@ -416,6 +458,10 @@ export interface TrackInfo {
   mimeType: string;
   mid: string;
   codecs: SimulcastCodecInfo[];
+  stereo: boolean;
+  /** true if RED (Redundant Encoding) is disabled for audio */
+  disableRed: boolean;
+  encryption: Encryption_Type;
 }
 
 /** provide information about available spatial layers */
@@ -424,7 +470,7 @@ export interface VideoLayer {
   quality: VideoQuality;
   width: number;
   height: number;
-  /** target bitrate, server will measure actual */
+  /** target bitrate in bit per second (bps), server will measure actual */
   bitrate: number;
   ssrc: number;
 }
@@ -1136,6 +1182,45 @@ export const ParticipantInfo = {
   },
 };
 
+function createBaseEncryption(): Encryption {
+  return {};
+}
+
+export const Encryption = {
+  encode(_: Encryption, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Encryption {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEncryption();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): Encryption {
+    return {};
+  },
+
+  toJSON(_: Encryption): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Encryption>, I>>(_: I): Encryption {
+    const message = createBaseEncryption();
+    return message;
+  },
+};
+
 function createBaseSimulcastCodecInfo(): SimulcastCodecInfo {
   return { mimeType: "", mid: "", cid: "", layers: [] };
 }
@@ -1231,6 +1316,9 @@ function createBaseTrackInfo(): TrackInfo {
     mimeType: "",
     mid: "",
     codecs: [],
+    stereo: false,
+    disableRed: false,
+    encryption: 0,
   };
 }
 
@@ -1275,6 +1363,15 @@ export const TrackInfo = {
     for (const v of message.codecs) {
       SimulcastCodecInfo.encode(v!, writer.uint32(106).fork()).ldelim();
     }
+    if (message.stereo === true) {
+      writer.uint32(112).bool(message.stereo);
+    }
+    if (message.disableRed === true) {
+      writer.uint32(120).bool(message.disableRed);
+    }
+    if (message.encryption !== 0) {
+      writer.uint32(128).int32(message.encryption);
+    }
     return writer;
   },
 
@@ -1324,6 +1421,15 @@ export const TrackInfo = {
         case 13:
           message.codecs.push(SimulcastCodecInfo.decode(reader, reader.uint32()));
           break;
+        case 14:
+          message.stereo = reader.bool();
+          break;
+        case 15:
+          message.disableRed = reader.bool();
+          break;
+        case 16:
+          message.encryption = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1347,6 +1453,9 @@ export const TrackInfo = {
       mimeType: isSet(object.mimeType) ? String(object.mimeType) : "",
       mid: isSet(object.mid) ? String(object.mid) : "",
       codecs: Array.isArray(object?.codecs) ? object.codecs.map((e: any) => SimulcastCodecInfo.fromJSON(e)) : [],
+      stereo: isSet(object.stereo) ? Boolean(object.stereo) : false,
+      disableRed: isSet(object.disableRed) ? Boolean(object.disableRed) : false,
+      encryption: isSet(object.encryption) ? encryption_TypeFromJSON(object.encryption) : 0,
     };
   },
 
@@ -1373,6 +1482,9 @@ export const TrackInfo = {
     } else {
       obj.codecs = [];
     }
+    message.stereo !== undefined && (obj.stereo = message.stereo);
+    message.disableRed !== undefined && (obj.disableRed = message.disableRed);
+    message.encryption !== undefined && (obj.encryption = encryption_TypeToJSON(message.encryption));
     return obj;
   },
 
@@ -1391,6 +1503,9 @@ export const TrackInfo = {
     message.mimeType = object.mimeType ?? "";
     message.mid = object.mid ?? "";
     message.codecs = object.codecs?.map((e) => SimulcastCodecInfo.fromPartial(e)) || [];
+    message.stereo = object.stereo ?? false;
+    message.disableRed = object.disableRed ?? false;
+    message.encryption = object.encryption ?? 0;
     return message;
   },
 };

package/src/proto/livekit_rtc.ts

@@ -9,6 +9,9 @@ import {
   DisconnectReason,
   disconnectReasonFromJSON,
   disconnectReasonToJSON,
+  Encryption_Type,
+  encryption_TypeFromJSON,
+  encryption_TypeToJSON,
   ParticipantInfo,
   ParticipantTracks,
   Room,
@@ -169,7 +172,8 @@ export interface SignalResponse {
     | { $case: "subscriptionPermissionUpdate"; subscriptionPermissionUpdate: SubscriptionPermissionUpdate }
     | { $case: "refreshToken"; refreshToken: string }
     | { $case: "trackUnpublished"; trackUnpublished: TrackUnpublishedResponse }
-    | { $case: "pong"; pong: number };
+    | { $case: "pong"; pong: number }
+    | { $case: "reconnect"; reconnect: ReconnectResponse };
 }
 
 export interface SimulcastCodec {
@@ -198,6 +202,7 @@ export interface AddTrackRequest {
   stereo: boolean;
   /** true if RED (Redundant Encoding) is disabled for audio */
   disableRed: boolean;
+  encryption: Encryption_Type;
 }
 
 export interface TrickleRequest {
@@ -232,6 +237,11 @@ export interface JoinResponse {
   serverInfo?: ServerInfo;
 }
 
+export interface ReconnectResponse {
+  iceServers: ICEServer[];
+  clientConfiguration?: ClientConfiguration;
+}
+
 export interface TrackPublishedResponse {
   cid: string;
   track?: TrackInfo;
@@ -267,7 +277,6 @@ export interface UpdateTrackSettings {
   width: number;
   /** for video, height to receive */
   height: number;
-  /** for video, frame rate to receive */
   fps: number;
 }
 
@@ -703,6 +712,9 @@ export const SignalResponse = {
     if (message.message?.$case === "pong") {
       writer.uint32(144).int64(message.message.pong);
     }
+    if (message.message?.$case === "reconnect") {
+      ReconnectResponse.encode(message.message.reconnect, writer.uint32(154).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -785,6 +797,9 @@ export const SignalResponse = {
         case 18:
           message.message = { $case: "pong", pong: longToNumber(reader.int64() as Long) };
           break;
+        case 19:
+          message.message = { $case: "reconnect", reconnect: ReconnectResponse.decode(reader, reader.uint32()) };
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -835,6 +850,8 @@ export const SignalResponse = {
         ? { $case: "trackUnpublished", trackUnpublished: TrackUnpublishedResponse.fromJSON(object.trackUnpublished) }
         : isSet(object.pong)
         ? { $case: "pong", pong: Number(object.pong) }
+        : isSet(object.reconnect)
+        ? { $case: "reconnect", reconnect: ReconnectResponse.fromJSON(object.reconnect) }
         : undefined,
     };
   },
@@ -882,6 +899,8 @@ export const SignalResponse = {
       ? TrackUnpublishedResponse.toJSON(message.message?.trackUnpublished)
       : undefined);
     message.message?.$case === "pong" && (obj.pong = Math.round(message.message?.pong));
+    message.message?.$case === "reconnect" &&
+      (obj.reconnect = message.message?.reconnect ? ReconnectResponse.toJSON(message.message?.reconnect) : undefined);
     return obj;
   },
 
@@ -999,6 +1018,13 @@ export const SignalResponse = {
     if (object.message?.$case === "pong" && object.message?.pong !== undefined && object.message?.pong !== null) {
       message.message = { $case: "pong", pong: object.message.pong };
     }
+    if (
+      object.message?.$case === "reconnect" &&
+      object.message?.reconnect !== undefined &&
+      object.message?.reconnect !== null
+    ) {
+      message.message = { $case: "reconnect", reconnect: ReconnectResponse.fromPartial(object.message.reconnect) };
+    }
     return message;
   },
 };
@@ -1085,6 +1111,7 @@ function createBaseAddTrackRequest(): AddTrackRequest {
     sid: "",
     stereo: false,
     disableRed: false,
+    encryption: 0,
   };
 }
 
@@ -1129,6 +1156,9 @@ export const AddTrackRequest = {
     if (message.disableRed === true) {
       writer.uint32(104).bool(message.disableRed);
     }
+    if (message.encryption !== 0) {
+      writer.uint32(112).int32(message.encryption);
+    }
     return writer;
   },
 
@@ -1178,6 +1208,9 @@ export const AddTrackRequest = {
         case 13:
           message.disableRed = reader.bool();
           break;
+        case 14:
+          message.encryption = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1203,6 +1236,7 @@ export const AddTrackRequest = {
       sid: isSet(object.sid) ? String(object.sid) : "",
       stereo: isSet(object.stereo) ? Boolean(object.stereo) : false,
       disableRed: isSet(object.disableRed) ? Boolean(object.disableRed) : false,
+      encryption: isSet(object.encryption) ? encryption_TypeFromJSON(object.encryption) : 0,
     };
   },
 
@@ -1229,6 +1263,7 @@ export const AddTrackRequest = {
     message.sid !== undefined && (obj.sid = message.sid);
     message.stereo !== undefined && (obj.stereo = message.stereo);
     message.disableRed !== undefined && (obj.disableRed = message.disableRed);
+    message.encryption !== undefined && (obj.encryption = encryption_TypeToJSON(message.encryption));
     return obj;
   },
 
@@ -1247,6 +1282,7 @@ export const AddTrackRequest = {
     message.sid = object.sid ?? "";
     message.stereo = object.stereo ?? false;
     message.disableRed = object.disableRed ?? false;
+    message.encryption = object.encryption ?? 0;
     return message;
   },
 };
@@ -1550,6 +1586,74 @@ export const JoinResponse = {
   },
 };
 
+function createBaseReconnectResponse(): ReconnectResponse {
+  return { iceServers: [], clientConfiguration: undefined };
+}
+
+export const ReconnectResponse = {
+  encode(message: ReconnectResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.iceServers) {
+      ICEServer.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.clientConfiguration !== undefined) {
+      ClientConfiguration.encode(message.clientConfiguration, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ReconnectResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReconnectResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.iceServers.push(ICEServer.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.clientConfiguration = ClientConfiguration.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ReconnectResponse {
+    return {
+      iceServers: Array.isArray(object?.iceServers) ? object.iceServers.map((e: any) => ICEServer.fromJSON(e)) : [],
+      clientConfiguration: isSet(object.clientConfiguration)
+        ? ClientConfiguration.fromJSON(object.clientConfiguration)
+        : undefined,
+    };
+  },
+
+  toJSON(message: ReconnectResponse): unknown {
+    const obj: any = {};
+    if (message.iceServers) {
+      obj.iceServers = message.iceServers.map((e) => e ? ICEServer.toJSON(e) : undefined);
+    } else {
+      obj.iceServers = [];
+    }
+    message.clientConfiguration !== undefined && (obj.clientConfiguration = message.clientConfiguration
+      ? ClientConfiguration.toJSON(message.clientConfiguration)
+      : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ReconnectResponse>, I>>(object: I): ReconnectResponse {
+    const message = createBaseReconnectResponse();
+    message.iceServers = object.iceServers?.map((e) => ICEServer.fromPartial(e)) || [];
+    message.clientConfiguration = (object.clientConfiguration !== undefined && object.clientConfiguration !== null)
+      ? ClientConfiguration.fromPartial(object.clientConfiguration)
+      : undefined;
+    return message;
+  },
+};
+
 function createBaseTrackPublishedResponse(): TrackPublishedResponse {
   return { cid: "", track: undefined };
 }