livekit-client 2.22.4 → 2.23.0

package/src/room/RTCEngine.ts

@@ -227,6 +227,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private attemptingReconnect: boolean = false;
 
+  private reconnectAbortController?: AbortController;
+
   private reconnectPolicy: ReconnectPolicy;
 
   private reconnectTimeout?: ReturnType<typeof setTimeout>;
@@ -236,6 +238,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   /** keeps track of how often an initial join connection has been tried */
   private joinAttempts: number = 0;
 
+  /**
+   * When the current join attempt began (`performance.now()`), taken at the top of `join` before
+   * the signal connection or the peer connections exist. Every attempt (a join retry, or the join
+   * inside a full restart) times itself from scratch. Consumed when the primary transport first
+   * connects, to hand the publisher its connection setup time; resumes never set it.
+   */
+  private joinStartedAt?: number;
+
   /** specifies how often an initial join connection is allowed to retry */
   private maxJoinAttempts: number = 1;
 
@@ -352,6 +362,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.maxJoinAttempts = opts.maxRetries;
     try {
       this.joinAttempts += 1;
+      this.joinStartedAt = performance.now();
 
       this.setupSignalClientCallbacks();
       // Whether the initial publisher offer is bundled with the join request. Computed once and
@@ -392,6 +403,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         useV0Path,
         offerProto,
       );
+      if (abortSignal?.aborted) {
+        this.log.info('join cancelled after the signal join response');
+        throw ConnectionError.cancelled('Connection aborted');
+      }
       this._isClosed = false;
       this.latestJoinResponse = joinResponse;
       this.participantSid = joinResponse.participant?.sid;
@@ -405,6 +420,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           // the server's ICE servers and topology, then negotiate separately rather than bundling
           // the offer with the join.
           await this.configure(joinResponse, !useV0Path);
+          if (abortSignal?.aborted) {
+            this.log.info('join cancelled after configuring peer connections');
+            throw ConnectionError.cancelled('Connection aborted');
+          }
           if (!useV0Path) {
             // The V1 first offer must carry the media layout so Firefox binds receive decoders for
             // subscribed tracks — without it, subscribed audio/video arrive as RTP but
@@ -420,6 +439,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         }
       }
 
+      if (this.joinStartedAt !== undefined) {
+        // Lets a video published before the transports connect be seeded from the time elapsed
+        // so far, rather than delaying its offer until the setup time is measured.
+        this.pcManager?.publisher.setConnectionStartedAt(this.joinStartedAt);
+      }
+
       this.registerOnLineListener();
       this.clientConfiguration = joinResponse.clientConfiguration;
       this.emit(EngineEvent.SignalConnected, joinResponse);
@@ -463,6 +488,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
    * having given up on reconnecting.
    */
   async close(reason?: string) {
+    this.reconnectAbortController?.abort();
+    this.reconnectAbortController = undefined;
     const unlock = await this.closingLock.lock();
     if (this.isClosed) {
       unlock();
@@ -471,6 +498,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     try {
       this._isClosed = true;
       this.joinAttempts = 0;
+      this.joinStartedAt = undefined;
       this.emit(EngineEvent.Closing);
       this.removeAllListeners();
       this.deregisterOnLineListener();
@@ -629,6 +657,16 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.publisherConnectionPromise = undefined;
       }
       if (connectionState === PCTransportState.CONNECTED) {
+        if (this.joinStartedAt !== undefined) {
+          // Connection setup time is the only network signal there is before the first video
+          // offer. Set synchronously, so it is in place before `room.connect()` resolves and the
+          // app can publish. A full restart joins again and builds new transports, so it is
+          // measured again; a resume keeps its estimator and never restarts the timer.
+          const setupTimeMs = Math.round(performance.now() - this.joinStartedAt);
+          this.joinStartedAt = undefined;
+          this.log.info(`connection setup took ${setupTimeMs} ms`);
+          this.pcManager?.publisher.setConnectionSetupTime(setupTimeMs);
+        }
         const shouldEmit = this.pcState === PCState.New;
         this.pcState = PCState.Connected;
         if (shouldEmit) {
@@ -899,6 +937,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       return;
     }
 
+    if (this.dataChannels.hasPublisherChannels) {
+      // Replacing live channels (the Safari null-id path in resumeConnection): the new ones start
+      // out connecting, so drop the memoized readiness check and make the next sender wait for
+      // them to open.
+      this.publisherConnectionPromise = undefined;
+    }
     this.dataChannels.createPublisherChannels(this.pcManager);
   }
 
@@ -1221,7 +1265,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       return;
     }
     if (connection === leaveReconnect) {
-      delay = 0;
+      // The server asked for a reconnect, so skip any remaining backoff. Use the policy's first
+      // retry delay instead of 0 so that clients told to reconnect together don't all reconnect
+      // at the same instant.
+      delay = this.getNextRetryDelay({ elapsedMs: duration, retryCount: 0 });
+      if (delay === null) {
+        disconnect(duration);
+        return;
+      }
     }
 
     this.log.debug(`reconnecting in ${delay}ms`);
@@ -1338,16 +1389,26 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.fullReconnectOnNext = false;
 
     let succeeded = false;
+    const abortController = new AbortController();
+    this.reconnectAbortController = abortController;
     try {
       this.attemptingReconnect = true;
       if (fullReconnect) {
-        await this.restartConnection();
+        await this.restartConnection(abortController.signal);
       } else {
         await this.resumeConnection(reason);
       }
+      if (abortController.signal.aborted) {
+        this.log.info('reconnect attempt cancelled, not marking it as succeeded');
+        return;
+      }
       this.clearPendingReconnect();
       succeeded = true;
     } catch (e) {
+      if (abortController.signal.aborted) {
+        this.log.info('reconnect attempt cancelled, not retrying', { error: e });
+        return;
+      }
       this.reconnectAttempts += 1;
       let recoverable = true;
       if (e instanceof UnexpectedConnectionState) {
@@ -1376,6 +1437,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         );
       }
     } finally {
+      // close() may already have cleared this (or a later attempt replaced it); only release our own
+      if (this.reconnectAbortController === abortController) {
+        this.reconnectAbortController = undefined;
+      }
       this.attemptingReconnect = false;
 
       // A full reconnect requested while this attempt was running (e.g. a `RECONNECT` leave
@@ -1399,8 +1464,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     return null;
   }
 
-  private async restartConnection(regionUrl?: string) {
+  private async restartConnection(abortSignal: AbortSignal, regionUrl?: string) {
     try {
+      if (abortSignal.aborted) {
+        this.log.info('full reconnect cancelled before starting', { regionUrl });
+        return;
+      }
       if (!this.url || !this.token) {
         // permanent failure, don't attempt reconnection
         throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -1414,6 +1483,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
       await this.cleanupPeerConnections();
       await this.cleanupClient();
+      if (abortSignal.aborted) {
+        this.log.info('full reconnect cancelled after cleaning up the previous session', {
+          regionUrl,
+        });
+        return;
+      }
 
       let joinResponse: JoinResponse;
       try {
@@ -1427,7 +1502,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
             regionUrl ?? this.url,
             this.token,
             this.signalOpts,
-            undefined,
+            abortSignal,
             !this.options.singlePeerConnection,
           )
         ).joinResponse;
@@ -1437,6 +1512,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         }
         throw new SignalReconnectError();
       }
+      if (abortSignal.aborted) {
+        this.log.info('full reconnect cancelled after the signal join response', { regionUrl });
+        return;
+      }
 
       if (this.shouldFailNext) {
         this.shouldFailNext = false;
@@ -1447,6 +1526,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.emit(EngineEvent.SignalRestarted, joinResponse);
 
       await this.waitForPCReconnected();
+      if (abortSignal.aborted) {
+        this.log.info('full reconnect cancelled after peer connections reconnected', { regionUrl });
+        return;
+      }
 
       // re-check signal connection state before setting engine as resumed
       if (this.client.currentState !== SignalConnectionState.CONNECTED) {
@@ -1457,9 +1540,17 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       // reconnect success
       this.emit(EngineEvent.Restarted);
     } catch (error) {
-      const nextRegionUrl = await this.regionStrategy?.getNextUrl();
+      if (abortSignal.aborted) {
+        this.log.info('full reconnect cancelled after a failed attempt', { regionUrl });
+        return;
+      }
+      const nextRegionUrl = await this.regionStrategy?.getNextUrl(abortSignal);
+      if (abortSignal.aborted) {
+        this.log.info('full reconnect cancelled during region selection', { regionUrl });
+        return;
+      }
       if (nextRegionUrl) {
-        await this.restartConnection(nextRegionUrl);
+        await this.restartConnection(abortSignal, nextRegionUrl);
         return;
       } else {
         // no more regions to try (or we're not on cloud)
@@ -1693,7 +1784,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
    * {@link FlowControlledDataChannel.waitForHeadroomWithLock}.
    */
   async waitForBufferHeadroom(kind: DataChannelKind) {
-    return this.flowControlFor(kind).waitForHeadroomWithLock();
+    const dc = this.dataChannelForKind(kind);
+    if (!dc) {
+      throw new UnexpectedConnectionState(`DataChannel not found, kind: ${kind}`);
+    }
+    return this.flowControlFor(kind).waitForHeadroomWithLock(dc);
   }
 
   /**

package/src/room/Room.test.ts

@@ -347,3 +347,119 @@ describe('stream state updates', () => {
     expect(participantEvents).not.toHaveBeenCalled();
   });
 });
+
+describe('audio context ownership', () => {
+  class StubAudioContext {
+    state: AudioContextState = 'running';
+
+    closed = false;
+
+    async close() {
+      this.closed = true;
+      this.state = 'closed';
+    }
+
+    async resume() {
+      this.state = 'running';
+    }
+  }
+
+  const created: StubAudioContext[] = [];
+
+  function stubAudioContext() {
+    created.length = 0;
+    vi.stubGlobal(
+      'AudioContext',
+      class extends StubAudioContext {
+        constructor() {
+          super();
+          created.push(this);
+        }
+      },
+    );
+  }
+
+  /** `acquireAudioContext` and `releaseAudioContext` are private */
+  function internals(room: Room) {
+    return room as unknown as {
+      acquireAudioContext: () => Promise<void>;
+      releaseAudioContext: (retained?: unknown[]) => Promise<void>;
+      audioContext?: StubAudioContext;
+      ownsAudioContext: boolean;
+      localParticipant: { setAudioContext: (ctx: AudioContext | undefined) => Promise<void> };
+    };
+  }
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it('closes a context it created for a webAudioMix object that supplies none', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+
+    await room.acquireAudioContext();
+    expect(created).toHaveLength(1);
+    expect(room.ownsAudioContext).toBe(true);
+    expect(room.audioContext).toBe(created[0]);
+
+    await room.releaseAudioContext();
+    expect(created[0].closed).toBe(true);
+    expect(room.audioContext).toBeUndefined();
+  });
+
+  it('leaves a supplied context open', async () => {
+    stubAudioContext();
+    const provided = new StubAudioContext();
+    const room = internals(
+      new Room({ webAudioMix: { audioContext: provided as unknown as AudioContext } }),
+    );
+
+    await room.acquireAudioContext();
+    expect(room.ownsAudioContext).toBe(false);
+    expect(created).toHaveLength(0);
+
+    await room.releaseAudioContext();
+    expect(provided.closed).toBe(false);
+  });
+
+  it('closes the context even when a retained track fails to detach', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+    await room.acquireAudioContext();
+
+    const retained = { setAudioContext: () => Promise.reject(new Error('detach failed')) };
+    await room.releaseAudioContext([retained]);
+
+    expect(created[0].closed).toBe(true);
+  });
+
+  it('does not build a context for an acquire queued behind a release', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+    await room.acquireAudioContext();
+    expect(created).toHaveLength(1);
+
+    // `startAudio` reads `audioContextReleased` before it waits on the mutex, so its acquire can
+    // already be queued behind a disconnect by the time the flag is set
+    const released = room.releaseAudioContext();
+    const acquired = room.acquireAudioContext();
+    await Promise.all([released, acquired]);
+
+    expect(created).toHaveLength(1);
+    expect(created[0].closed).toBe(true);
+    expect(room.audioContext).toBeUndefined();
+  });
+
+  it('closes the outgoing context even when a participant fails to move off it', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+    await room.acquireAudioContext();
+
+    vi.spyOn(room.localParticipant, 'setAudioContext').mockRejectedValue(new Error('move failed'));
+    await room.releaseAudioContext();
+
+    expect(created[0].closed).toBe(true);
+  });
+});