livekit-client 0.18.6 → 1.0.2

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/DeviceManager.ts

@@ -32,8 +32,11 @@ export default class DeviceManager {
           video: kind !== 'audioinput' && kind !== 'audiooutput',
           audio: kind !== 'videoinput',
         };
-        await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
+        const stream = await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
         devices = await navigator.mediaDevices.enumerateDevices();
+        stream.getTracks().forEach((track) => {
+          track.stop();
+        });
       }
     }
     if (kind) {

package/src/room/RTCEngine.ts

@@ -48,6 +48,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   rtcConfig: RTCConfiguration = {};
 
+  get isClosed() {
+    return this._isClosed;
+  }
+
   private lossyDC?: RTCDataChannel;
 
   // @ts-ignore noUnusedLocals
@@ -64,7 +68,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private pcState: PCState = PCState.New;
 
-  private isClosed: boolean = true;
+  private _isClosed: boolean = true;
 
   private pendingTrackResolvers: { [key: string]: (info: TrackInfo) => void } = {};
 
@@ -89,18 +93,25 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private connectedServerAddr?: string;
 
+  private attemptingReconnect: boolean = false;
+
   constructor() {
     super();
     this.client = new SignalClient();
   }
 
-  async join(url: string, token: string, opts?: SignalOptions): Promise<JoinResponse> {
+  async join(
+    url: string,
+    token: string,
+    opts?: SignalOptions,
+    abortSignal?: AbortSignal,
+  ): Promise<JoinResponse> {
     this.url = url;
     this.token = token;
     this.signalOpts = opts;
 
-    const joinResponse = await this.client.join(url, token, opts);
-    this.isClosed = false;
+    const joinResponse = await this.client.join(url, token, opts, abortSignal);
+    this._isClosed = false;
 
     this.subscriberPrimary = joinResponse.subscriberPrimary;
     if (!this.publisher) {
@@ -117,7 +128,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 
   close() {
-    this.isClosed = true;
+    this._isClosed = true;
 
     this.removeAllListeners();
     if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
@@ -220,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') {
@@ -244,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');
@@ -403,7 +417,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   // continues to work, we can reconnect to websocket to continue the session
   // after a number of retries, we'll close and give up permanently
   private handleDisconnect = (connection: string) => {
-    if (this.isClosed) {
+    if (this._isClosed) {
       return;
     }
     log.debug(`${connection} disconnected`);
@@ -414,17 +428,25 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     const delay = this.reconnectAttempts * this.reconnectAttempts * 300;
     setTimeout(async () => {
-      if (this.isClosed) {
+      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 {
@@ -434,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 });
@@ -441,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;
@@ -458,6 +488,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           this.emit(EngineEvent.Disconnected);
           this.close();
         }
+      } finally {
+        this.attemptingReconnect = false;
       }
     }, delay);
   };
@@ -473,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;
@@ -502,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);