livekit-client 1.0.1 → 1.0.2

package/src/proto/livekit_models.ts

@@ -311,6 +311,12 @@ export function participantInfo_StateToJSON(object: ParticipantInfo_State): stri
   }
 }
 
+export interface SimulcastCodecInfo {
+  mimeType: string;
+  mid: string;
+  cid: string;
+}
+
 export interface TrackInfo {
   sid: string;
   type: TrackType;
@@ -333,6 +339,7 @@ export interface TrackInfo {
   /** mime type of codec */
   mimeType: string;
   mid: string;
+  codecs: SimulcastCodecInfo[];
 }
 
 /** provide information about available spatial layers */
@@ -1007,6 +1014,73 @@ export const ParticipantInfo = {
   },
 };
 
+function createBaseSimulcastCodecInfo(): SimulcastCodecInfo {
+  return { mimeType: '', mid: '', cid: '' };
+}
+
+export const SimulcastCodecInfo = {
+  encode(message: SimulcastCodecInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.mimeType !== '') {
+      writer.uint32(10).string(message.mimeType);
+    }
+    if (message.mid !== '') {
+      writer.uint32(18).string(message.mid);
+    }
+    if (message.cid !== '') {
+      writer.uint32(26).string(message.cid);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SimulcastCodecInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSimulcastCodecInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.mimeType = reader.string();
+          break;
+        case 2:
+          message.mid = reader.string();
+          break;
+        case 3:
+          message.cid = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SimulcastCodecInfo {
+    return {
+      mimeType: isSet(object.mimeType) ? String(object.mimeType) : '',
+      mid: isSet(object.mid) ? String(object.mid) : '',
+      cid: isSet(object.cid) ? String(object.cid) : '',
+    };
+  },
+
+  toJSON(message: SimulcastCodecInfo): unknown {
+    const obj: any = {};
+    message.mimeType !== undefined && (obj.mimeType = message.mimeType);
+    message.mid !== undefined && (obj.mid = message.mid);
+    message.cid !== undefined && (obj.cid = message.cid);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SimulcastCodecInfo>, I>>(object: I): SimulcastCodecInfo {
+    const message = createBaseSimulcastCodecInfo();
+    message.mimeType = object.mimeType ?? '';
+    message.mid = object.mid ?? '';
+    message.cid = object.cid ?? '';
+    return message;
+  },
+};
+
 function createBaseTrackInfo(): TrackInfo {
   return {
     sid: '',
@@ -1021,6 +1095,7 @@ function createBaseTrackInfo(): TrackInfo {
     layers: [],
     mimeType: '',
     mid: '',
+    codecs: [],
   };
 }
 
@@ -1062,6 +1137,9 @@ export const TrackInfo = {
     if (message.mid !== '') {
       writer.uint32(98).string(message.mid);
     }
+    for (const v of message.codecs) {
+      SimulcastCodecInfo.encode(v!, writer.uint32(106).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1108,6 +1186,9 @@ export const TrackInfo = {
         case 12:
           message.mid = reader.string();
           break;
+        case 13:
+          message.codecs.push(SimulcastCodecInfo.decode(reader, reader.uint32()));
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1132,6 +1213,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))
+        : [],
     };
   },
 
@@ -1153,6 +1237,11 @@ export const TrackInfo = {
     }
     message.mimeType !== undefined && (obj.mimeType = message.mimeType);
     message.mid !== undefined && (obj.mid = message.mid);
+    if (message.codecs) {
+      obj.codecs = message.codecs.map((e) => (e ? SimulcastCodecInfo.toJSON(e) : undefined));
+    } else {
+      obj.codecs = [];
+    }
     return obj;
   },
 
@@ -1170,6 +1259,7 @@ export const TrackInfo = {
     message.layers = object.layers?.map((e) => VideoLayer.fromPartial(e)) || [];
     message.mimeType = object.mimeType ?? '';
     message.mid = object.mid ?? '';
+    message.codecs = object.codecs?.map((e) => SimulcastCodecInfo.fromPartial(e)) || [];
     return message;
   },
 };

package/src/proto/livekit_rtc.ts

@@ -89,6 +89,38 @@ export function streamStateToJSON(object: StreamState): string {
   }
 }
 
+export enum CandidateProtocol {
+  UDP = 0,
+  TCP = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function candidateProtocolFromJSON(object: any): CandidateProtocol {
+  switch (object) {
+    case 0:
+    case 'UDP':
+      return CandidateProtocol.UDP;
+    case 1:
+    case 'TCP':
+      return CandidateProtocol.TCP;
+    case -1:
+    case 'UNRECOGNIZED':
+    default:
+      return CandidateProtocol.UNRECOGNIZED;
+  }
+}
+
+export function candidateProtocolToJSON(object: CandidateProtocol): string {
+  switch (object) {
+    case CandidateProtocol.UDP:
+      return 'UDP';
+    case CandidateProtocol.TCP:
+      return 'TCP';
+    default:
+      return 'UNKNOWN';
+  }
+}
+
 export interface SignalRequest {
   /** initial join exchange, for publisher */
   offer?: SessionDescription | undefined;
@@ -156,6 +188,12 @@ export interface SignalResponse {
   trackUnpublished?: TrackUnpublishedResponse | undefined;
 }
 
+export interface SimulcastCodec {
+  codec: string;
+  cid: string;
+  enableSimulcastLayers: boolean;
+}
+
 export interface AddTrackRequest {
   /** client ID of track, to match it when RTC track is received */
   cid: string;
@@ -170,6 +208,7 @@ export interface AddTrackRequest {
   disableDtx: boolean;
   source: TrackSource;
   layers: VideoLayer[];
+  simulcastCodecs: SimulcastCodec[];
 }
 
 export interface TrickleRequest {
@@ -289,9 +328,15 @@ export interface SubscribedQuality {
   enabled: boolean;
 }
 
+export interface SubscribedCodec {
+  codec: string;
+  qualities: SubscribedQuality[];
+}
+
 export interface SubscribedQualityUpdate {
   trackSid: string;
   subscribedQualities: SubscribedQuality[];
+  subscribedCodecs: SubscribedCodec[];
 }
 
 export interface TrackPermission {
@@ -335,6 +380,8 @@ export interface SimulateScenario {
   migration: boolean | undefined;
   /** server to send leave */
   serverLeave: boolean | undefined;
+  /** switch candidate protocol to tcp */
+  switchCandidateProtocol: CandidateProtocol | undefined;
 }
 
 function createBaseSignalRequest(): SignalRequest {
@@ -864,6 +911,76 @@ export const SignalResponse = {
   },
 };
 
+function createBaseSimulcastCodec(): SimulcastCodec {
+  return { codec: '', cid: '', enableSimulcastLayers: false };
+}
+
+export const SimulcastCodec = {
+  encode(message: SimulcastCodec, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.codec !== '') {
+      writer.uint32(10).string(message.codec);
+    }
+    if (message.cid !== '') {
+      writer.uint32(18).string(message.cid);
+    }
+    if (message.enableSimulcastLayers === true) {
+      writer.uint32(24).bool(message.enableSimulcastLayers);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SimulcastCodec {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSimulcastCodec();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.codec = reader.string();
+          break;
+        case 2:
+          message.cid = reader.string();
+          break;
+        case 3:
+          message.enableSimulcastLayers = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SimulcastCodec {
+    return {
+      codec: isSet(object.codec) ? String(object.codec) : '',
+      cid: isSet(object.cid) ? String(object.cid) : '',
+      enableSimulcastLayers: isSet(object.enableSimulcastLayers)
+        ? Boolean(object.enableSimulcastLayers)
+        : false,
+    };
+  },
+
+  toJSON(message: SimulcastCodec): unknown {
+    const obj: any = {};
+    message.codec !== undefined && (obj.codec = message.codec);
+    message.cid !== undefined && (obj.cid = message.cid);
+    message.enableSimulcastLayers !== undefined &&
+      (obj.enableSimulcastLayers = message.enableSimulcastLayers);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SimulcastCodec>, I>>(object: I): SimulcastCodec {
+    const message = createBaseSimulcastCodec();
+    message.codec = object.codec ?? '';
+    message.cid = object.cid ?? '';
+    message.enableSimulcastLayers = object.enableSimulcastLayers ?? false;
+    return message;
+  },
+};
+
 function createBaseAddTrackRequest(): AddTrackRequest {
   return {
     cid: '',
@@ -875,6 +992,7 @@ function createBaseAddTrackRequest(): AddTrackRequest {
     disableDtx: false,
     source: 0,
     layers: [],
+    simulcastCodecs: [],
   };
 }
 
@@ -907,6 +1025,9 @@ export const AddTrackRequest = {
     for (const v of message.layers) {
       VideoLayer.encode(v!, writer.uint32(74).fork()).ldelim();
     }
+    for (const v of message.simulcastCodecs) {
+      SimulcastCodec.encode(v!, writer.uint32(82).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -944,6 +1065,9 @@ export const AddTrackRequest = {
         case 9:
           message.layers.push(VideoLayer.decode(reader, reader.uint32()));
           break;
+        case 10:
+          message.simulcastCodecs.push(SimulcastCodec.decode(reader, reader.uint32()));
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -965,6 +1089,9 @@ export const AddTrackRequest = {
       layers: Array.isArray(object?.layers)
         ? object.layers.map((e: any) => VideoLayer.fromJSON(e))
         : [],
+      simulcastCodecs: Array.isArray(object?.simulcastCodecs)
+        ? object.simulcastCodecs.map((e: any) => SimulcastCodec.fromJSON(e))
+        : [],
     };
   },
 
@@ -983,6 +1110,13 @@ export const AddTrackRequest = {
     } else {
       obj.layers = [];
     }
+    if (message.simulcastCodecs) {
+      obj.simulcastCodecs = message.simulcastCodecs.map((e) =>
+        e ? SimulcastCodec.toJSON(e) : undefined,
+      );
+    } else {
+      obj.simulcastCodecs = [];
+    }
     return obj;
   },
 
@@ -997,6 +1131,8 @@ export const AddTrackRequest = {
     message.disableDtx = object.disableDtx ?? false;
     message.source = object.source ?? 0;
     message.layers = object.layers?.map((e) => VideoLayer.fromPartial(e)) || [];
+    message.simulcastCodecs =
+      object.simulcastCodecs?.map((e) => SimulcastCodec.fromPartial(e)) || [];
     return message;
   },
 };
@@ -2284,8 +2420,72 @@ export const SubscribedQuality = {
   },
 };
 
+function createBaseSubscribedCodec(): SubscribedCodec {
+  return { codec: '', qualities: [] };
+}
+
+export const SubscribedCodec = {
+  encode(message: SubscribedCodec, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.codec !== '') {
+      writer.uint32(10).string(message.codec);
+    }
+    for (const v of message.qualities) {
+      SubscribedQuality.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SubscribedCodec {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubscribedCodec();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.codec = reader.string();
+          break;
+        case 2:
+          message.qualities.push(SubscribedQuality.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SubscribedCodec {
+    return {
+      codec: isSet(object.codec) ? String(object.codec) : '',
+      qualities: Array.isArray(object?.qualities)
+        ? object.qualities.map((e: any) => SubscribedQuality.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: SubscribedCodec): unknown {
+    const obj: any = {};
+    message.codec !== undefined && (obj.codec = message.codec);
+    if (message.qualities) {
+      obj.qualities = message.qualities.map((e) => (e ? SubscribedQuality.toJSON(e) : undefined));
+    } else {
+      obj.qualities = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SubscribedCodec>, I>>(object: I): SubscribedCodec {
+    const message = createBaseSubscribedCodec();
+    message.codec = object.codec ?? '';
+    message.qualities = object.qualities?.map((e) => SubscribedQuality.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 function createBaseSubscribedQualityUpdate(): SubscribedQualityUpdate {
-  return { trackSid: '', subscribedQualities: [] };
+  return { trackSid: '', subscribedQualities: [], subscribedCodecs: [] };
 }
 
 export const SubscribedQualityUpdate = {
@@ -2296,6 +2496,9 @@ export const SubscribedQualityUpdate = {
     for (const v of message.subscribedQualities) {
       SubscribedQuality.encode(v!, writer.uint32(18).fork()).ldelim();
     }
+    for (const v of message.subscribedCodecs) {
+      SubscribedCodec.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -2312,6 +2515,9 @@ export const SubscribedQualityUpdate = {
         case 2:
           message.subscribedQualities.push(SubscribedQuality.decode(reader, reader.uint32()));
           break;
+        case 3:
+          message.subscribedCodecs.push(SubscribedCodec.decode(reader, reader.uint32()));
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -2326,6 +2532,9 @@ export const SubscribedQualityUpdate = {
       subscribedQualities: Array.isArray(object?.subscribedQualities)
         ? object.subscribedQualities.map((e: any) => SubscribedQuality.fromJSON(e))
         : [],
+      subscribedCodecs: Array.isArray(object?.subscribedCodecs)
+        ? object.subscribedCodecs.map((e: any) => SubscribedCodec.fromJSON(e))
+        : [],
     };
   },
 
@@ -2339,6 +2548,13 @@ export const SubscribedQualityUpdate = {
     } else {
       obj.subscribedQualities = [];
     }
+    if (message.subscribedCodecs) {
+      obj.subscribedCodecs = message.subscribedCodecs.map((e) =>
+        e ? SubscribedCodec.toJSON(e) : undefined,
+      );
+    } else {
+      obj.subscribedCodecs = [];
+    }
     return obj;
   },
 
@@ -2349,6 +2565,8 @@ export const SubscribedQualityUpdate = {
     message.trackSid = object.trackSid ?? '';
     message.subscribedQualities =
       object.subscribedQualities?.map((e) => SubscribedQuality.fromPartial(e)) || [];
+    message.subscribedCodecs =
+      object.subscribedCodecs?.map((e) => SubscribedCodec.fromPartial(e)) || [];
     return message;
   },
 };
@@ -2757,6 +2975,7 @@ function createBaseSimulateScenario(): SimulateScenario {
     nodeFailure: undefined,
     migration: undefined,
     serverLeave: undefined,
+    switchCandidateProtocol: undefined,
   };
 }
 
@@ -2774,6 +2993,9 @@ export const SimulateScenario = {
     if (message.serverLeave !== undefined) {
       writer.uint32(32).bool(message.serverLeave);
     }
+    if (message.switchCandidateProtocol !== undefined) {
+      writer.uint32(40).int32(message.switchCandidateProtocol);
+    }
     return writer;
   },
 
@@ -2796,6 +3018,9 @@ export const SimulateScenario = {
         case 4:
           message.serverLeave = reader.bool();
           break;
+        case 5:
+          message.switchCandidateProtocol = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -2810,6 +3035,9 @@ export const SimulateScenario = {
       nodeFailure: isSet(object.nodeFailure) ? Boolean(object.nodeFailure) : undefined,
       migration: isSet(object.migration) ? Boolean(object.migration) : undefined,
       serverLeave: isSet(object.serverLeave) ? Boolean(object.serverLeave) : undefined,
+      switchCandidateProtocol: isSet(object.switchCandidateProtocol)
+        ? candidateProtocolFromJSON(object.switchCandidateProtocol)
+        : undefined,
     };
   },
 
@@ -2819,6 +3047,11 @@ export const SimulateScenario = {
     message.nodeFailure !== undefined && (obj.nodeFailure = message.nodeFailure);
     message.migration !== undefined && (obj.migration = message.migration);
     message.serverLeave !== undefined && (obj.serverLeave = message.serverLeave);
+    message.switchCandidateProtocol !== undefined &&
+      (obj.switchCandidateProtocol =
+        message.switchCandidateProtocol !== undefined
+          ? candidateProtocolToJSON(message.switchCandidateProtocol)
+          : undefined);
     return obj;
   },
 
@@ -2828,6 +3061,7 @@ export const SimulateScenario = {
     message.nodeFailure = object.nodeFailure ?? undefined;
     message.migration = object.migration ?? undefined;
     message.serverLeave = object.serverLeave ?? undefined;
+    message.switchCandidateProtocol = object.switchCandidateProtocol ?? undefined;
     return message;
   },
 };

package/src/room/RTCEngine.ts

@@ -93,6 +93,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private connectedServerAddr?: string;
 
+  private attemptingReconnect: boolean = false;
+
   constructor() {
     super();
     this.client = new SignalClient();
@@ -229,7 +231,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
     this.primaryPC = primaryPC;
     primaryPC.onconnectionstatechange = async () => {
-      log.trace('connection state changed', {
+      log.debug('primary PC state changed', {
         state: primaryPC.connectionState,
       });
       if (primaryPC.connectionState === 'connected') {
@@ -253,6 +255,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
     };
     secondaryPC.onconnectionstatechange = async () => {
+      log.debug('secondary PC state changed', {
+        state: secondaryPC.connectionState,
+      });
       // also reconnect if secondary peerconnection fails
       if (secondaryPC.connectionState === 'failed') {
         this.handleDisconnect('secondary peerconnection');
@@ -426,14 +431,22 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       if (this._isClosed) {
         return;
       }
+      // guard for attempting reconnection multiple times while one attempt is still not finished
+      if (this.attemptingReconnect) {
+        return;
+      }
       if (
         isFireFox() || // TODO remove once clientConfiguration handles firefox case server side
-        this.clientConfiguration?.resumeConnection === ClientConfigSetting.DISABLED
+        this.clientConfiguration?.resumeConnection === ClientConfigSetting.DISABLED ||
+        // signaling state could change to closed due to hardware sleep
+        // those connections cannot be resumed
+        (this.primaryPC?.signalingState ?? 'closed') === 'closed'
       ) {
         this.fullReconnectOnNext = true;
       }
 
       try {
+        this.attemptingReconnect = true;
         if (this.fullReconnectOnNext) {
           await this.restartConnection();
         } else {
@@ -443,6 +456,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.fullReconnectOnNext = false;
       } catch (e) {
         this.reconnectAttempts += 1;
+        let reconnectRequired = false;
         let recoverable = true;
         if (e instanceof UnexpectedConnectionState) {
           log.debug('received unrecoverable error', { error: e });
@@ -450,7 +464,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           recoverable = false;
         } else if (!(e instanceof SignalReconnectError)) {
           // cannot resume
+          reconnectRequired = true;
+        }
+
+        // when we flip from resume to reconnect, we need to reset reconnectAttempts
+        // this is needed to fire the right reconnecting events
+        if (reconnectRequired && !this.fullReconnectOnNext) {
           this.fullReconnectOnNext = true;
+          this.reconnectAttempts = 0;
         }
 
         const duration = Date.now() - this.reconnectStart;
@@ -467,6 +488,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           this.emit(EngineEvent.Disconnected);
           this.close();
         }
+      } finally {
+        this.attemptingReconnect = false;
       }
     }, delay);
   };
@@ -482,6 +505,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.emit(EngineEvent.Restarting);
     }
 
+    if (this.client.isConnected) {
+      this.client.sendLeave();
+    }
+    this.client.close();
     this.primaryPC = undefined;
     this.publisher?.close();
     this.publisher = undefined;
@@ -511,6 +538,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!this.publisher || !this.subscriber) {
       throw new UnexpectedConnectionState('publisher and subscriber connections unset');
     }
+
     log.info(`resuming signal connection, attempt ${this.reconnectAttempts}`);
     if (this.reconnectAttempts === 0) {
       this.emit(EngineEvent.Resuming);