livekit-client 2.22.0 → 2.22.2

package/src/api/utils.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { createRtcUrl, createValidateUrl } from './utils';
+import { createRtcUrl, createValidateUrl, getAbortReasonAsString } from './utils';
 
 describe('createRtcUrl', () => {
   it('should create a basic RTC URL', () => {
@@ -125,3 +125,22 @@ describe('createValidateUrl', () => {
     expect(parsedResult.pathname).toBe('/sub/path/rtc/validate');
   });
 });
+
+describe('getAbortReasonAsString', () => {
+  it('uses an error message, which is how the connect timeout describes itself', () => {
+    // the timeout hands the abort handler an Error, not a signal
+    expect(
+      getAbortReasonAsString(new Error('room connection has timed out (signal)'), 'fallback'),
+    ).toBe('room connection has timed out (signal)');
+  });
+
+  it("reads an abort signal's reason", () => {
+    const controller = new AbortController();
+    controller.abort('user navigated away');
+    expect(getAbortReasonAsString(controller.signal, 'fallback')).toBe('user navigated away');
+  });
+
+  it('falls back when there is nothing to describe', () => {
+    expect(getAbortReasonAsString(undefined, 'fallback')).toBe('fallback');
+  });
+});

package/src/api/utils.ts

@@ -45,6 +45,11 @@ export function getAbortReasonAsString(
   signal: AbortSignal | Error | unknown,
   defaultMessage = 'Unknown reason',
 ) {
+  // the connect timeout hands this an Error rather than a signal, and its message is the only
+  // description of what went wrong — without this a timeout reports itself as a generic abort
+  if (signal instanceof Error) {
+    return signal.message;
+  }
   if (!(signal instanceof AbortSignal)) {
     return defaultMessage;
   }

package/src/e2ee/E2eeManager.ts

@@ -12,6 +12,7 @@ import { EngineEvent, ParticipantEvent, RoomEvent } from '../room/events';
 import type RemoteTrack from '../room/track/RemoteTrack';
 import RemoteVideoTrack from '../room/track/RemoteVideoTrack';
 import type { Track } from '../room/track/Track';
+import type { TrackPublication } from '../room/track/TrackPublication';
 import type { TrackPublishOptions, VideoCodec } from '../room/track/options';
 import { mimeTypeToVideoCodecString } from '../room/track/utils';
 import {
@@ -23,7 +24,7 @@ import {
 } from '../room/utils';
 import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 import type { BaseKeyProvider } from './KeyProvider';
-import { E2EE_FLAG } from './constants';
+import { E2EE_FLAG, E2EE_TRACK_ID } from './constants';
 import { type E2EEManagerCallbacks, EncryptionEvent, KeyProviderEvent } from './events';
 import type {
   DecryptDataRequestMessage,
@@ -279,20 +280,14 @@ export class E2EEManager
 
   private setupEventListeners(room: Room, keyProvider: BaseKeyProvider) {
     room.on(RoomEvent.TrackPublished, (pub, participant) =>
-      this.setParticipantCryptorEnabled(
-        pub.trackInfo!.encryption !== Encryption_Type.NONE,
-        participant.identity,
-      ),
+      this.setParticipantCryptorEnabledForPublication(pub, participant.identity),
     );
     room
       .on(RoomEvent.ConnectionStateChanged, (state) => {
         if (state === ConnectionState.Connected) {
           room.remoteParticipants.forEach((participant) => {
             participant.trackPublications.forEach((pub) => {
-              this.setParticipantCryptorEnabled(
-                pub.trackInfo!.encryption !== Encryption_Type.NONE,
-                participant.identity,
-              );
+              this.setParticipantCryptorEnabledForPublication(pub, participant.identity);
             });
           });
         }
@@ -482,6 +477,29 @@ export class E2EEManager
     this.worker.postMessage(msg);
   }
 
+  /**
+   * Derive the participant's encryption state from one of its publications.
+   * Publications without trackInfo are skipped rather than thrown on: throwing
+   * inside the forEach above would leave every remaining participant without an
+   * encryption state, and a cryptor with unknown state can no longer decrypt.
+   */
+  private setParticipantCryptorEnabledForPublication(
+    pub: TrackPublication,
+    participantIdentity: string,
+  ) {
+    if (!pub.trackInfo) {
+      log.warn('skipping e2ee enabled update for publication without trackInfo', {
+        participant: participantIdentity,
+        trackSid: pub.trackSid,
+      });
+      return;
+    }
+    this.setParticipantCryptorEnabled(
+      pub.trackInfo.encryption !== Encryption_Type.NONE,
+      participantIdentity,
+    );
+  }
+
   private setupE2EEReceiver(track: RemoteTrack, remoteId: string, trackInfo?: TrackInfo) {
     if (!track.receiver) {
       return;
@@ -541,21 +559,27 @@ export class E2EEManager
         codec,
         hasPacketTrailer,
       };
-      // @ts-ignore
       receiver.transform = new RTCRtpScriptTransform(this.worker, options);
     } else {
-      if (E2EE_FLAG in receiver && codec) {
-        // update track-specific state when the transceiver is reused
+      if (E2EE_FLAG in receiver && E2EE_TRACK_ID in receiver) {
+        // The transceiver is being reused for a new track. We cannot set up a new
+        // pipeline from here: this receiver's encoded streams were transferred to
+        // the worker on first setup and a transferred stream can't be transferred
+        // again, while createEncodedStreams() may only be called once per receiver.
+        // So hand the worker the new track/participant and let it re-point (and if
+        // necessary rebuild) the cryptor that still owns those streams.
         const msg: UpdateCodecMessage = {
           kind: 'updateCodec',
           data: {
             trackId,
+            previousTrackId: receiver[E2EE_TRACK_ID] as string,
             codec,
             participantIdentity,
             hasPacketTrailer,
           },
         };
         this.worker.postMessage(msg);
+        receiver[E2EE_TRACK_ID] = trackId;
         return;
       }
       // @ts-ignore
@@ -582,7 +606,6 @@ export class E2EEManager
           trackId: trackId,
           codec,
           participantIdentity: participantIdentity,
-          isReuse: E2EE_FLAG in receiver,
           hasPacketTrailer,
         },
       };
@@ -591,6 +614,8 @@ export class E2EEManager
 
     // @ts-ignore
     receiver[E2EE_FLAG] = true;
+    // @ts-ignore
+    receiver[E2EE_TRACK_ID] = trackId;
   }
 
   /**
@@ -636,7 +661,6 @@ export class E2EEManager
           codec,
           trackId,
           participantIdentity: this.room.localParticipant.identity,
-          isReuse: false,
           hasPacketTrailer: hasFrameMetadataPublishOptions(frameMetadata),
           packetTrailer: frameMetadata,
         },

package/src/e2ee/constants.ts

@@ -29,6 +29,12 @@ export const IV_LENGTH = 12;
 // flag set to indicate that e2ee has been setup for sender/receiver;
 export const E2EE_FLAG = 'lk_e2ee';
 
+/**
+ * trackId a receiver's/sender's encoded stream pipeline was last set up for.
+ * Needed to recover the right cryptor when a transceiver gets reused.
+ */
+export const E2EE_TRACK_ID = 'lk_e2ee_track_id';
+
 export const SALT = 'LKFrameEncryptionKey';
 
 export const KEY_PROVIDER_DEFAULTS: KeyProviderOptions = {