livekit-client 1.5.0 → 1.6.1

package/src/room/RTCEngine.ts

@@ -29,7 +29,7 @@ import {
   UnexpectedConnectionState,
 } from './errors';
 import { EngineEvent } from './events';
-import PCTransport from './PCTransport';
+import PCTransport, { PCEvents } from './PCTransport';
 import type { ReconnectContext, ReconnectPolicy } from './ReconnectPolicy';
 import type LocalTrack from './track/LocalTrack';
 import type LocalVideoTrack from './track/LocalVideoTrack';
@@ -38,6 +38,7 @@ import type { TrackPublishOptions, VideoCodec } from './track/options';
 import { Track } from './track/Track';
 import {
   isWeb,
+  Mutex,
   sleep,
   supportsAddTrack,
   supportsSetCodecPreferences,
@@ -130,12 +131,15 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   /** specifies how often an initial join connection is allowed to retry */
   private maxJoinAttempts: number = 1;
 
+  private closingLock: Mutex;
+
   constructor(private options: InternalRoomOptions) {
     super();
     this.client = new SignalClient();
     this.client.signalLatency = this.options.expSignalLatency;
     this.reconnectPolicy = this.options.reconnectPolicy;
     this.registerOnLineListener();
+    this.closingLock = new Mutex();
   }
 
   async join(
@@ -179,30 +183,40 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
   }
 
-  close() {
-    this._isClosed = true;
-    this.removeAllListeners();
-    this.deregisterOnLineListener();
-    this.clearPendingReconnect();
-    if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
-      this.publisher.pc.getSenders().forEach((sender) => {
-        try {
-          // TODO: react-native-webrtc doesn't have removeTrack yet.
-          if (this.publisher?.pc.removeTrack) {
-            this.publisher?.pc.removeTrack(sender);
-          }
-        } catch (e) {
-          log.warn('could not removeTrack', { error: e });
-        }
-      });
-      this.publisher.close();
-      this.publisher = undefined;
+  async close() {
+    const unlock = await this.closingLock.lock();
+    if (this.isClosed) {
+      unlock();
+      return;
     }
-    if (this.subscriber) {
-      this.subscriber.close();
-      this.subscriber = undefined;
+    try {
+      this._isClosed = true;
+      this.emit(EngineEvent.Closing);
+      this.removeAllListeners();
+      this.deregisterOnLineListener();
+      this.clearPendingReconnect();
+      if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
+        this.publisher.pc.getSenders().forEach((sender) => {
+          try {
+            // TODO: react-native-webrtc doesn't have removeTrack yet.
+            if (this.publisher?.pc.removeTrack) {
+              this.publisher?.pc.removeTrack(sender);
+            }
+          } catch (e) {
+            log.warn('could not removeTrack', { error: e });
+          }
+        });
+        this.publisher.close();
+        this.publisher = undefined;
+      }
+      if (this.subscriber) {
+        this.subscriber.close();
+        this.subscriber = undefined;
+      }
+      await this.client.close();
+    } finally {
+      unlock();
     }
-    this.client.close();
   }
 
   addTrack(req: AddTrackRequest): Promise<TrackInfo> {
@@ -335,7 +349,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         const shouldEmit = this.pcState === PCState.New;
         this.pcState = PCState.Connected;
         if (shouldEmit) {
-          this.emit(EngineEvent.Connected);
+          this.emit(EngineEvent.Connected, joinResponse);
         }
       } else if (primaryPC.connectionState === 'failed') {
         // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
@@ -784,9 +798,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     if (this.client.isConnected) {
-      this.client.sendLeave();
+      await this.client.sendLeave();
     }
-    this.client.close();
+    await this.client.close();
     this.primaryPC = undefined;
     this.publisher?.close();
     this.publisher = undefined;
@@ -906,52 +920,99 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
   }
 
-  private async ensurePublisherConnected(kind: DataPacket_Kind) {
-    if (!this.subscriberPrimary) {
-      return;
-    }
-
-    if (!this.publisher) {
-      throw new ConnectionError('publisher connection not set');
+  /**
+   * @internal
+   */
+  async ensureDataTransportConnected(
+    kind: DataPacket_Kind,
+    subscriber: boolean = this.subscriberPrimary,
+  ) {
+    const transport = subscriber ? this.subscriber : this.publisher;
+    const transportName = subscriber ? 'Subscriber' : 'Publisher';
+    if (!transport) {
+      throw new ConnectionError(`${transportName} connection not set`);
     }
 
-    if (!this.publisher.isICEConnected && this.publisher.pc.iceConnectionState !== 'checking') {
+    if (
+      !subscriber &&
+      !this.publisher?.isICEConnected &&
+      this.publisher?.pc.iceConnectionState !== 'checking'
+    ) {
       // start negotiation
       this.negotiate();
     }
 
-    const targetChannel = this.dataChannelForKind(kind);
+    const targetChannel = this.dataChannelForKind(kind, subscriber);
     if (targetChannel?.readyState === 'open') {
       return;
     }
 
-    // wait until publisher ICE connected
+    // wait until ICE connected
     const endTime = new Date().getTime() + this.peerConnectionTimeout;
     while (new Date().getTime() < endTime) {
-      if (this.publisher.isICEConnected && this.dataChannelForKind(kind)?.readyState === 'open') {
+      if (
+        transport.isICEConnected &&
+        this.dataChannelForKind(kind, subscriber)?.readyState === 'open'
+      ) {
         return;
       }
       await sleep(50);
     }
 
     throw new ConnectionError(
-      `could not establish publisher connection, state ${this.publisher?.pc.iceConnectionState}`,
+      `could not establish ${transportName} connection, state: ${transport.pc.iceConnectionState}`,
     );
   }
 
+  private async ensurePublisherConnected(kind: DataPacket_Kind) {
+    await this.ensureDataTransportConnected(kind, false);
+  }
+
   /** @internal */
-  negotiate() {
-    if (!this.publisher) {
-      return;
-    }
+  negotiate(): Promise<void> {
+    // observe signal state
+    return new Promise<void>((resolve, reject) => {
+      if (!this.publisher) {
+        reject(new NegotiationError('publisher is not defined'));
+        return;
+      }
 
-    this.hasPublished = true;
+      this.hasPublished = true;
 
-    this.publisher.negotiate((e) => {
-      if (e instanceof NegotiationError) {
-        this.fullReconnectOnNext = true;
-      }
-      this.handleDisconnect('negotiation');
+      const handleClosed = () => {
+        log.debug('engine disconnected while negotiation was ongoing');
+        cleanup();
+        resolve();
+        return;
+      };
+
+      this.on(EngineEvent.Closing, handleClosed);
+
+      const negotiationTimeout = setTimeout(() => {
+        reject('negotiation timed out');
+        this.handleDisconnect('negotiation');
+      }, this.peerConnectionTimeout);
+
+      const cleanup = () => {
+        clearTimeout(negotiationTimeout);
+        this.off(EngineEvent.Closing, handleClosed);
+      };
+
+      this.publisher.once(PCEvents.NegotiationStarted, () => {
+        this.publisher?.once(PCEvents.NegotiationComplete, () => {
+          cleanup();
+          resolve();
+        });
+      });
+
+      this.publisher.negotiate((e) => {
+        cleanup();
+        reject(e);
+        if (e instanceof NegotiationError) {
+          this.fullReconnectOnNext = true;
+        }
+        this.handleDisconnect('negotiation');
+      });
     });
   }
 
@@ -1040,13 +1101,14 @@ async function getConnectedAddress(pc: RTCPeerConnection): Promise<string | unde
 class SignalReconnectError extends Error {}
 
 export type EngineEventCallbacks = {
-  connected: () => void;
+  connected: (joinResp: JoinResponse) => void;
   disconnected: (reason?: DisconnectReason) => void;
   resuming: () => void;
   resumed: () => void;
   restarting: () => void;
   restarted: (joinResp: JoinResponse) => void;
   signalResumed: () => void;
+  closing: () => void;
   mediaTrackAdded: (
     track: MediaStreamTrack,
     streams: MediaStream,