livekit-client 1.14.1 → 1.14.3

package/src/room/RTCEngine.ts

@@ -108,7 +108,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private subscriberPrimary: boolean = false;
 
-  private primaryPC?: RTCPeerConnection;
+  private primaryTransport?: PCTransport;
 
   private pcState: PCState = PCState.New;
 
@@ -247,12 +247,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 
   async cleanupPeerConnections() {
-    if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
-      this.publisher.pc.getSenders().forEach((sender) => {
+    if (this.publisher && this.publisher.getSignallingState() !== 'closed') {
+      this.publisher.getSenders().forEach((sender) => {
         try {
           // TODO: react-native-webrtc doesn't have removeTrack yet.
-          if (this.publisher?.pc.removeTrack) {
-            this.publisher?.pc.removeTrack(sender);
+          if (this.publisher?.canRemoveTrack()) {
+            this.publisher?.removeTrack(sender);
           }
         } catch (e) {
           log.warn('could not removeTrack', { error: e });
@@ -268,7 +268,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.subscriber = undefined;
     }
     this.hasPublished = false;
-    this.primaryPC = undefined;
+    this.primaryTransport = undefined;
 
     const dcCleanup = (dc: RTCDataChannel | undefined) => {
       if (!dc) return;
@@ -336,7 +336,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       delete this.pendingTrackResolvers[sender.track.id];
     }
     try {
-      this.publisher?.pc.removeTrack(sender);
+      this.publisher?.removeTrack(sender);
       return true;
     } catch (e: unknown) {
       log.warn('failed to remove track', { error: e, method: 'removeTrack' });
@@ -353,10 +353,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 
   async getConnectedServerAddress(): Promise<string | undefined> {
-    if (this.primaryPC === undefined) {
+    if (this.primaryTransport === undefined) {
       return undefined;
     }
-    return getConnectedAddress(this.primaryPC);
+    return this.primaryTransport.getConnectedAddress();
   }
 
   /* @internal */
@@ -374,53 +374,44 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     const rtcConfig = this.makeRTCConfiguration(joinResponse);
 
-    if (this.signalOpts?.e2eeEnabled) {
-      log.debug('E2EE - setting up transports with insertable streams');
-      //  this makes sure that no data is sent before the transforms are ready
-      // @ts-ignore
-      rtcConfig.encodedInsertableStreams = true;
-    }
-
     const googConstraints = { optional: [{ googDscp: true }] };
     this.publisher = new PCTransport(rtcConfig, googConstraints);
     this.subscriber = new PCTransport(rtcConfig);
 
     this.emit(EngineEvent.TransportsCreated, this.publisher, this.subscriber);
 
-    this.publisher.pc.onicecandidate = (ev) => {
-      if (!ev.candidate) return;
-      log.trace('adding ICE candidate for peer', ev.candidate);
-      this.client.sendIceCandidate(ev.candidate, SignalTarget.PUBLISHER);
+    this.publisher.onIceCandidate = (candidate) => {
+      log.trace('adding ICE candidate for peer', candidate);
+      this.client.sendIceCandidate(candidate, SignalTarget.PUBLISHER);
     };
 
-    this.subscriber.pc.onicecandidate = (ev) => {
-      if (!ev.candidate) return;
-      this.client.sendIceCandidate(ev.candidate, SignalTarget.SUBSCRIBER);
+    this.subscriber.onIceCandidate = (candidate) => {
+      this.client.sendIceCandidate(candidate, SignalTarget.SUBSCRIBER);
     };
 
     this.publisher.onOffer = (offer) => {
       this.client.sendOffer(offer);
     };
 
-    let primaryPC = this.publisher.pc;
-    let secondaryPC = this.subscriber.pc;
+    let primaryTransport = this.publisher;
+    let secondaryTransport = this.subscriber;
     let subscriberPrimary = joinResponse.subscriberPrimary;
     if (subscriberPrimary) {
-      primaryPC = this.subscriber.pc;
-      secondaryPC = this.publisher.pc;
+      primaryTransport = this.subscriber;
+      secondaryTransport = this.publisher;
       // in subscriber primary mode, server side opens sub data channels.
-      this.subscriber.pc.ondatachannel = this.handleDataChannel;
+      this.subscriber.onDataChannel = this.handleDataChannel;
     }
-    this.primaryPC = primaryPC;
-    primaryPC.onconnectionstatechange = async () => {
-      log.debug(`primary PC state changed ${primaryPC.connectionState}`);
-      if (primaryPC.connectionState === 'connected') {
+    this.primaryTransport = primaryTransport;
+    primaryTransport.onConnectionStateChange = async (connectionState) => {
+      log.debug(`primary PC state changed ${connectionState}`);
+      if (connectionState === 'connected') {
         const shouldEmit = this.pcState === PCState.New;
         this.pcState = PCState.Connected;
         if (shouldEmit) {
           this.emit(EngineEvent.Connected, joinResponse);
         }
-      } else if (primaryPC.connectionState === 'failed') {
+      } else if (connectionState === 'failed') {
         // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
         if (this.pcState === PCState.Connected) {
           this.pcState = PCState.Disconnected;
@@ -434,10 +425,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         }
       }
     };
-    secondaryPC.onconnectionstatechange = async () => {
-      log.debug(`secondary PC state changed ${secondaryPC.connectionState}`);
+    secondaryTransport.onConnectionStateChange = async (connectionState) => {
+      log.debug(`secondary PC state changed ${connectionState}`);
       // also reconnect if secondary peerconnection fails
-      if (secondaryPC.connectionState === 'failed') {
+      if (connectionState === 'failed') {
         this.handleDisconnect(
           'secondary peerconnection',
           subscriberPrimary
@@ -447,7 +438,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
     };
 
-    this.subscriber.pc.ontrack = (ev: RTCTrackEvent) => {
+    this.subscriber.onTrack = (ev: RTCTrackEvent) => {
       this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
     };
 
@@ -462,7 +453,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
       log.debug('received server answer', {
         RTCSdpType: sd.type,
-        signalingState: this.publisher.pc.signalingState.toString(),
+        signalingState: this.publisher.getSignallingState().toString(),
       });
       await this.publisher.setRemoteDescription(sd);
     };
@@ -487,7 +478,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
       log.debug('received server offer', {
         RTCSdpType: sd.type,
-        signalingState: this.subscriber.pc.signalingState.toString(),
+        signalingState: this.subscriber.getSignallingState().toString(),
       });
       await this.subscriber.setRemoteDescription(sd);
 
@@ -518,7 +509,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.client.onLeave = (leave?: LeaveRequest) => {
       if (leave?.canReconnect) {
         this.fullReconnectOnNext = true;
-        this.primaryPC = undefined;
+        this.primaryTransport = undefined;
         // reconnect immediately instead of waiting for next attempt
         this.handleDisconnect(leaveReconnect);
       } else {
@@ -531,6 +522,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private makeRTCConfiguration(serverResponse: JoinResponse | ReconnectResponse): RTCConfiguration {
     const rtcConfig = { ...this.rtcConfig };
+    if (this.signalOpts?.e2eeEnabled) {
+      log.debug('E2EE - setting up transports with insertable streams');
+      //  this makes sure that no data is sent before the transforms are ready
+      // @ts-ignore
+      rtcConfig.encodedInsertableStreams = true;
+    }
 
     // update ICE servers before creating PeerConnection
     if (serverResponse.iceServers && !rtcConfig.iceServers) {
@@ -579,12 +576,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     // create data channels
-    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
+    this.lossyDC = this.publisher.createDataChannel(lossyDataChannel, {
       // will drop older packets that arrive
       ordered: true,
       maxRetransmits: 0,
     });
-    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
+    this.reliableDC = this.publisher.createDataChannel(reliableDataChannel, {
       ordered: true,
     });
 
@@ -765,7 +762,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       transceiverInit.sendEncodings = encodings;
     }
     // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
-    const transceiver = await this.publisher.pc.addTransceiver(
+    const transceiver = await this.publisher.addTransceiver(
       track.mediaStreamTrack,
       transceiverInit,
     );
@@ -791,7 +788,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       transceiverInit.sendEncodings = encodings;
     }
     // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
-    const transceiver = await this.publisher.pc.addTransceiver(
+    const transceiver = await this.publisher.addTransceiver(
       simulcastTrack.mediaStreamTrack,
       transceiverInit,
     );
@@ -807,7 +804,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!this.publisher) {
       throw new UnexpectedConnectionState('publisher is closed');
     }
-    return this.publisher.pc.addTrack(track);
+    return this.publisher.addTrack(track);
   }
 
   // websocket reconnect behavior. if websocket is interrupted, and the PeerConnection
@@ -872,7 +869,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       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.primaryTransport?.getSignallingState() ?? 'closed') === 'closed'
     ) {
       this.fullReconnectOnNext = true;
     }
@@ -999,13 +996,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       const res = await this.client.reconnect(this.url, this.token, this.participantSid, reason);
       if (res) {
         const rtcConfig = this.makeRTCConfiguration(res);
-        this.publisher.pc.setConfiguration(rtcConfig);
-        this.subscriber.pc.setConfiguration(rtcConfig);
+        this.publisher.setConfiguration(rtcConfig);
+        this.subscriber.setConfiguration(rtcConfig);
       }
     } catch (e) {
       let message = '';
       if (e instanceof Error) {
         message = e.message;
+        log.error(e.message);
       }
       if (e instanceof ConnectionError && e.reason === ConnectionErrorReason.NotAllowed) {
         throw new UnexpectedConnectionState('could not reconnect, token might be expired');
@@ -1084,7 +1082,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     log.debug('waiting for peer connection to reconnect');
     while (now - startTime < this.peerConnectionTimeout) {
-      if (this.primaryPC === undefined) {
+      if (this.primaryTransport === undefined) {
         // we can abort early, connection is hosed
         break;
       } else if (
@@ -1092,8 +1090,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         // this means we'd have to check its status manually and update address
         // manually
         now - startTime > minReconnectWait &&
-        this.primaryPC?.connectionState === 'connected' &&
-        (!this.hasPublished || this.publisher?.pc.connectionState === 'connected')
+        this.primaryTransport?.getConnectionState() === 'connected' &&
+        (!this.hasPublished || this.publisher?.getConnectionState() === 'connected')
       ) {
         this.pcState = PCState.Connected;
       }
@@ -1172,7 +1170,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (
       !subscriber &&
       !this.publisher?.isICEConnected &&
-      this.publisher?.pc.iceConnectionState !== 'checking'
+      this.publisher?.getICEConnectionState() !== 'checking'
     ) {
       // start negotiation
       this.negotiate();
@@ -1196,7 +1194,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     throw new ConnectionError(
-      `could not establish ${transportName} connection, state: ${transport.pc.iceConnectionState}`,
+      `could not establish ${transportName} connection, state: ${transport.getICEConnectionState()}`,
     );
   }
 
@@ -1207,12 +1205,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   /* @internal */
   verifyTransport(): boolean {
     // primary connection
-    if (!this.primaryPC) {
+    if (!this.primaryTransport) {
       return false;
     }
     if (
-      this.primaryPC.connectionState === 'closed' ||
-      this.primaryPC.connectionState === 'failed'
+      this.primaryTransport.getConnectionState() === 'closed' ||
+      this.primaryTransport.getConnectionState() === 'failed'
     ) {
       return false;
     }
@@ -1223,8 +1221,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         return false;
       }
       if (
-        this.publisher.pc.connectionState === 'closed' ||
-        this.publisher.pc.connectionState === 'failed'
+        this.publisher.getConnectionState() === 'closed' ||
+        this.publisher.getConnectionState() === 'failed'
       ) {
         return false;
       }
@@ -1355,40 +1353,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 }
 
-async function getConnectedAddress(pc: RTCPeerConnection): Promise<string | undefined> {
-  let selectedCandidatePairId = '';
-  const candidatePairs = new Map<string, RTCIceCandidatePairStats>();
-  // id -> candidate ip
-  const candidates = new Map<string, string>();
-  const stats: RTCStatsReport = await pc.getStats();
-  stats.forEach((v) => {
-    switch (v.type) {
-      case 'transport':
-        selectedCandidatePairId = v.selectedCandidatePairId;
-        break;
-      case 'candidate-pair':
-        if (selectedCandidatePairId === '' && v.selected) {
-          selectedCandidatePairId = v.id;
-        }
-        candidatePairs.set(v.id, v);
-        break;
-      case 'remote-candidate':
-        candidates.set(v.id, `${v.address}:${v.port}`);
-        break;
-      default:
-    }
-  });
-
-  if (selectedCandidatePairId === '') {
-    return undefined;
-  }
-  const selectedID = candidatePairs.get(selectedCandidatePairId)?.remoteCandidateId;
-  if (selectedID === undefined) {
-    return undefined;
-  }
-  return candidates.get(selectedID);
-}
-
 class SignalReconnectError extends Error {}
 
 export type EngineEventCallbacks = {

package/src/room/Room.ts

@@ -452,6 +452,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
               error instanceof ConnectionError &&
               (error.status === 401 || error.reason === ConnectionErrorReason.Cancelled)
             ) {
+              this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
               reject(error);
               return;
             }
@@ -462,9 +463,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
             );
             await connectFn(resolve, reject, nextUrl);
           } else {
+            this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
             reject(e);
           }
         } else {
+          this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
           reject(e);
         }
       }
@@ -593,8 +596,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.setupLocalParticipantEvents();
       this.emit(RoomEvent.SignalConnected);
     } catch (err) {
+      await this.engine.close();
       this.recreateEngine();
-      this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
       const resultingError = new ConnectionError(`could not establish signal connection`);
       if (err instanceof Error) {
         resultingError.message = `${resultingError.message}: ${err.message}`;
@@ -608,8 +611,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
 
     if (abortController.signal.aborted) {
+      await this.engine.close();
       this.recreateEngine();
-      this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
       throw new ConnectionError(`Connection attempt aborted`);
     }
 
@@ -619,8 +622,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         abortController,
       );
     } catch (e) {
+      await this.engine.close();
       this.recreateEngine();
-      this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
       throw e;
     }
 
@@ -799,7 +802,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * - `startAudio`
    * - `getUserMedia`
    */
-  async startAudio() {
+  startAudio = async () => {
     const elements: Array<HTMLMediaElement> = [];
     const browser = getBrowser();
     if (browser && browser.os === 'iOS') {
@@ -860,7 +863,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.handleAudioPlaybackFailed(err);
       throw err;
     }
-  }
+  };
 
   /**
    * Returns true if audio playback is enabled
@@ -970,6 +973,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
       .on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
       .on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
+      .on(ParticipantEvent.AudioStreamAcquired, this.startAudio)
       .on(
         ParticipantEvent.ParticipantPermissionsChanged,
         this.onLocalParticipantPermissionsChanged,
@@ -1166,6 +1170,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         .off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
         .off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
         .off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
+        .off(ParticipantEvent.AudioStreamAcquired, this.startAudio)
         .off(
           ParticipantEvent.ParticipantPermissionsChanged,
           this.onLocalParticipantPermissionsChanged,
@@ -1546,14 +1551,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private sendSyncState() {
-    if (
-      this.engine.subscriber === undefined ||
-      this.engine.subscriber.pc.localDescription === null
-    ) {
+    const previousAnswer = this.engine.subscriber?.getLocalDescription();
+    const previousOffer = this.engine.subscriber?.getRemoteDescription();
+
+    if (!previousAnswer) {
       return;
     }
-    const previousAnswer = this.engine.subscriber.pc.localDescription;
-    const previousOffer = this.engine.subscriber.pc.remoteDescription;
 
     /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
           in this case, we send unsub tracks, so server add all tracks to this

package/src/room/defaults.ts

@@ -1,11 +1,13 @@
 import type { InternalRoomConnectOptions, InternalRoomOptions } from '../options';
 import DefaultReconnectPolicy from './DefaultReconnectPolicy';
-import { AudioPresets, ScreenSharePresets, VideoPresets } from './track/options';
 import type {
   AudioCaptureOptions,
   TrackPublishDefaults,
   VideoCaptureOptions,
 } from './track/options';
+import { AudioPresets, ScreenSharePresets, VideoPresets } from './track/options';
+
+export const defaultVideoCodec = 'vp8';
 
 export const publishDefaults: TrackPublishDefaults = {
   /**
@@ -19,7 +21,7 @@ export const publishDefaults: TrackPublishDefaults = {
   simulcast: true,
   screenShareEncoding: ScreenSharePresets.h1080fps15.encoding,
   stopMicTrackOnMute: false,
-  videoCodec: 'vp8',
+  videoCodec: defaultVideoCodec,
   backupCodec: false,
 } as const;
 

package/src/room/events.ts

@@ -223,7 +223,7 @@ export enum RoomEvent {
    * be emitted.
    *
    * args: (pub: [[RemoteTrackPublication]],
-   *        status: [[TrackPublication.SubscriptionStatus]],
+   *        status: [[TrackPublication.PermissionStatus]],
    *        participant: [[RemoteParticipant]])
    */
   TrackSubscriptionPermissionChanged = 'trackSubscriptionPermissionChanged',
@@ -441,6 +441,10 @@ export enum ParticipantEvent {
   /** @internal */
   MediaDevicesError = 'mediaDevicesError',
 
+  // fired only on LocalParticipant
+  /** @internal */
+  AudioStreamAcquired = 'audioStreamAcquired',
+
   /**
    * A participant's permission has changed. Currently only fired on LocalParticipant.
    * args: (prevPermissions: [[ParticipantPermission]])