@livekit/rtc-node 0.13.20 → 0.13.22

package/src/room.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
+import { Mutex } from '@livekit/mutex';
 import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
 import EventEmitter from 'events';
 import { ByteStreamReader, TextStreamReader } from './data_streams/stream_reader.js';
@@ -17,10 +18,10 @@ import { FfiClient, FfiClientEvent, FfiHandle } from './ffi_client.js';
 import { log } from './log.js';
 import type { Participant } from './participant.js';
 import { LocalParticipant, RemoteParticipant } from './participant.js';
-import { EncryptionState } from './proto/e2ee_pb.js';
+import { EncryptionState, EncryptionType } from './proto/e2ee_pb.js';
 import type { FfiEvent } from './proto/ffi_pb.js';
 import type { DisconnectReason, OwnedParticipant } from './proto/participant_pb.js';
-import type { DataStream_Trailer } from './proto/room_pb.js';
+import type { DataStream_Trailer, DisconnectCallback } from './proto/room_pb.js';
 import {
   type ConnectCallback,
   ConnectRequest,
@@ -60,7 +61,11 @@ export const defaultRtcConfiguration: RtcConfiguration = {
 export interface RoomOptions {
   autoSubscribe: boolean;
   dynacast: boolean;
+  /**
+   * @deprecated Use `encryption` instead. See x for details
+   */
   e2ee?: E2EEOptions;
+  encryption?: E2EEOptions;
   rtcConfig?: RtcConfiguration;
 }
 
@@ -68,6 +73,7 @@ export const defaultRoomOptions = new FfiRoomOptions({
   autoSubscribe: true,
   dynacast: false,
   e2ee: undefined,
+  encryption: undefined,
   rtcConfig: undefined,
   adaptiveStream: false,
   joinRetries: 1,
@@ -76,6 +82,12 @@ export const defaultRoomOptions = new FfiRoomOptions({
 export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>) {
   private info?: RoomInfo;
   private ffiHandle?: FfiHandle;
+  /**
+   * used to ensure events are processed sequentially and allow for
+   * the local participant to acquire the lock while doing state updates related to FFI events
+   * before processing the next events
+   */
+  private ffiEventLock = new Mutex();
 
   private byteStreamControllers = new Map<string, StreamController<DataStream_Chunk>>();
   private textStreamControllers = new Map<string, StreamController<DataStream_Chunk>>();
@@ -174,7 +186,10 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
    */
   async connect(url: string, token: string, opts?: RoomOptions) {
     const options = { ...defaultRoomOptions, ...opts };
-    const e2eeOptions = { ...defaultE2EEOptions, ...options.e2ee };
+    const e2eeEnabled = options.encryption || options.e2ee;
+    const e2eeOptions = options.encryption
+      ? { ...defaultE2EEOptions, ...options.encryption }
+      : { ...defaultE2EEOptions, ...options.e2ee };
 
     const req = new ConnectRequest({
       url: url,
@@ -200,11 +215,14 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     switch (cb.message.case) {
       case 'result':
         this.ffiHandle = new FfiHandle(cb.message.value.room!.handle!.id!);
-        this.e2eeManager = options.e2ee && new E2EEManager(this.ffiHandle.handle, e2eeOptions);
+        this.e2eeManager = e2eeEnabled && new E2EEManager(this.ffiHandle.handle, e2eeOptions);
 
         this.info = cb.message.value.room!.info;
         this.connectionState = ConnectionState.CONN_CONNECTED;
-        this.localParticipant = new LocalParticipant(cb.message.value.localParticipant!);
+        this.localParticipant = new LocalParticipant(
+          cb.message.value.localParticipant!,
+          this.ffiEventLock,
+        );
 
         for (const pt of cb.message.value.participants) {
           const rp = this.createRemoteParticipant(pt.participant!);
@@ -230,7 +248,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       return;
     }
 
-    FfiClient.instance.request<DisconnectResponse>({
+    const res = FfiClient.instance.request<DisconnectResponse>({
       message: {
         case: 'disconnect',
         value: {
@@ -239,6 +257,10 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       },
     });
 
+    await FfiClient.instance.waitFor<DisconnectCallback>((ev: FfiEvent) => {
+      return ev.message.case == 'disconnect' && ev.message.value.asyncId == res.asyncId;
+    });
+
     FfiClient.instance.removeListener(FfiClientEvent.FfiEvent, this.onFfiEvent);
     this.removeAllListeners();
   }
@@ -279,22 +301,27 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     this.byteStreamHandlers.delete(topic);
   }
 
-  private onFfiEvent = (ffiEvent: FfiEvent) => {
-    if (!this.localParticipant || !this.ffiHandle || !this.info) {
-      this.preConnectEvents.push(ffiEvent);
-      return;
-    }
+  private onFfiEvent = async (ffiEvent: FfiEvent) => {
+    const unlock = await this.ffiEventLock.lock();
+    try {
+      if (!this.localParticipant || !this.ffiHandle || !this.info) {
+        this.preConnectEvents.push(ffiEvent);
+        return;
+      }
 
-    // process preConnectEvents if we received the connectCallback after the events were queued
-    for (const ev of this.preConnectEvents) {
-      this.processFfiEvent(ev);
-    }
-    this.preConnectEvents = [];
+      // process preConnectEvents if we received the connectCallback after the events were queued
+      for (const ev of this.preConnectEvents) {
+        await this.processFfiEvent(ev);
+      }
+      this.preConnectEvents = [];
 
-    this.processFfiEvent(ffiEvent);
+      await this.processFfiEvent(ffiEvent);
+    } finally {
+      unlock();
+    }
   };
 
-  private processFfiEvent = (ffiEvent: FfiEvent) => {
+  private processFfiEvent = async (ffiEvent: FfiEvent) => {
     if (!this.localParticipant || !this.ffiHandle || !this.info) {
       throw new Error('processFfiEvent called before connect');
     }
@@ -330,24 +357,38 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       this.emit(RoomEvent.ParticipantConnected, participant);
     } else if (ev.case == 'participantDisconnected') {
       const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
-      this.remoteParticipants.delete(participant!.identity);
-      participant!.info.disconnectReason = ev.value.disconnectReason;
-      this.emit(RoomEvent.ParticipantDisconnected, participant!);
+      if (participant) {
+        this.remoteParticipants.delete(participant.identity);
+        participant.info.disconnectReason = ev.value.disconnectReason;
+        this.emit(RoomEvent.ParticipantDisconnected, participant);
+      } else {
+        console.log(`RoomEvent.ParticipantDisconnected: Could not find participant`);
+      }
     } else if (ev.case == 'localTrackPublished') {
-      const publication = this.localParticipant!.trackPublications.get(ev.value.trackSid!);
-      this.emit(RoomEvent.LocalTrackPublished, publication!, this.localParticipant!);
+      const publication = this.localParticipant.trackPublications.get(ev.value.trackSid!);
+      this.emit(RoomEvent.LocalTrackPublished, publication!, this.localParticipant);
     } else if (ev.case == 'localTrackUnpublished') {
-      const publication = this.localParticipant!.trackPublications.get(ev.value.publicationSid!);
-      this.localParticipant!.trackPublications.delete(ev.value.publicationSid!);
+      const publication = this.localParticipant.trackPublications.get(ev.value.publicationSid!);
+      this.localParticipant.trackPublications.delete(ev.value.publicationSid!);
       this.emit(RoomEvent.LocalTrackUnpublished, publication!, this.localParticipant!);
     } else if (ev.case == 'localTrackSubscribed') {
-      const publication = this.localParticipant!.trackPublications.get(ev.value.trackSid!);
-      publication!.resolveFirstSubscription();
-      this.emit(RoomEvent.LocalTrackSubscribed, publication!.track!);
+      const publication = this.localParticipant.trackPublications.get(ev.value.trackSid!);
+      if (publication) {
+        publication.resolveFirstSubscription();
+        this.emit(RoomEvent.LocalTrackSubscribed, publication!.track!);
+      } else {
+        console.warn(`RoomEvent.LocalTrackSubscribed: Publication not found: ${ev.value.trackSid}`);
+      }
     } else if (ev.case == 'trackPublished') {
       const participant = this.remoteParticipants.get(ev.value.participantIdentity!);
       const publication = new RemoteTrackPublication(ev.value.publication!);
-      participant!.trackPublications.set(publication.sid!, publication);
+      if (participant) {
+        participant.trackPublications.set(publication.sid!, publication);
+      } else {
+        console.warn(
+          `RoomEvent.TrackPublished: Could not find participant: ${ev.value.participantIdentity}`,
+        );
+      }
       this.emit(RoomEvent.TrackPublished, publication, participant!);
     } else if (ev.case == 'trackUnpublished') {
       const participant = this.requireRemoteParticipant(ev.value.participantIdentity!);
@@ -355,92 +396,139 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       participant.trackPublications.delete(ev.value.publicationSid!);
       if (publication) {
         this.emit(RoomEvent.TrackUnpublished, publication, participant);
+      } else {
+        console.warn(`RoomEvent.TrackUnpublished: Could not find publication`);
       }
     } else if (ev.case == 'trackSubscribed') {
       const ownedTrack = ev.value.track!;
       const trackInfo = ownedTrack.info!;
-      const { participant, publication } = this.requirePublicationOfRemoteParticipant(
-        ev.value.participantIdentity!,
-        trackInfo.sid!,
-      );
-      publication.subscribed = true;
-      if (trackInfo.kind == TrackKind.KIND_VIDEO) {
-        publication.track = new RemoteVideoTrack(ownedTrack);
-      } else if (trackInfo.kind == TrackKind.KIND_AUDIO) {
-        publication.track = new RemoteAudioTrack(ownedTrack);
-      }
+      try {
+        const { participant, publication } = this.requirePublicationOfRemoteParticipant(
+          ev.value.participantIdentity!,
+          trackInfo.sid!,
+        );
+        publication.subscribed = true;
+        if (trackInfo.kind == TrackKind.KIND_VIDEO) {
+          publication.track = new RemoteVideoTrack(ownedTrack);
+        } else if (trackInfo.kind == TrackKind.KIND_AUDIO) {
+          publication.track = new RemoteAudioTrack(ownedTrack);
+        }
 
-      this.emit(RoomEvent.TrackSubscribed, publication.track!, publication, participant);
+        this.emit(RoomEvent.TrackSubscribed, publication.track!, publication, participant);
+      } catch (e: any) {
+        console.warn(`RoomEvent.TrackSubscribed: ${e.message}`);
+      }
     } else if (ev.case == 'trackUnsubscribed') {
-      const { participant, publication } = this.requirePublicationOfRemoteParticipant(
-        ev.value.participantIdentity!,
-        ev.value.trackSid!,
-      );
-      const track = publication.track!;
-      publication.track = undefined;
-      publication.subscribed = false;
-      this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
+      try {
+        const { participant, publication } = this.requirePublicationOfRemoteParticipant(
+          ev.value.participantIdentity!,
+          ev.value.trackSid!,
+        );
+        const track = publication.track!;
+        publication.track = undefined;
+        publication.subscribed = false;
+        this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
+      } catch (e: any) {
+        console.warn(`RoomEvent.TrackUnsubscribed: ${e.message}`);
+      }
     } else if (ev.case == 'trackSubscriptionFailed') {
-      const participant = this.requireRemoteParticipant(ev.value.participantIdentity!);
-      this.emit(RoomEvent.TrackSubscriptionFailed, ev.value.trackSid!, participant, ev.value.error);
+      try {
+        const participant = this.requireRemoteParticipant(ev.value.participantIdentity!);
+        this.emit(
+          RoomEvent.TrackSubscriptionFailed,
+          ev.value.trackSid!,
+          participant,
+          ev.value.error,
+        );
+      } catch (e: any) {
+        console.warn(`RoomEvent.TrackSubscriptionFailed: ${e.message}`);
+      }
     } else if (ev.case == 'trackMuted') {
-      const { participant, publication } = this.requirePublicationOfParticipant(
-        ev.value.participantIdentity!,
-        ev.value.trackSid!,
-      );
-      publication.info!.muted = true;
-      if (publication.track) {
-        publication.track.info!.muted = true;
+      try {
+        const { participant, publication } = this.requirePublicationOfParticipant(
+          ev.value.participantIdentity!,
+          ev.value.trackSid!,
+        );
+        publication.info!.muted = true;
+        if (publication.track) {
+          publication.track.info!.muted = true;
+        }
+        this.emit(RoomEvent.TrackMuted, publication, participant);
+      } catch (e: any) {
+        console.warn(`RoomEvent.TrackMuted: ${e.message}`);
       }
-      this.emit(RoomEvent.TrackMuted, publication, participant);
     } else if (ev.case == 'trackUnmuted') {
-      const { participant, publication } = this.requirePublicationOfParticipant(
-        ev.value.participantIdentity!,
-        ev.value.trackSid!,
-      );
-      publication.info!.muted = false;
-      if (publication.track) {
-        publication.track.info!.muted = false;
+      try {
+        const { participant, publication } = this.requirePublicationOfParticipant(
+          ev.value.participantIdentity!,
+          ev.value.trackSid!,
+        );
+        publication.info!.muted = false;
+        if (publication.track) {
+          publication.track.info!.muted = false;
+        }
+        this.emit(RoomEvent.TrackUnmuted, publication, participant);
+      } catch (e: any) {
+        console.warn(`RoomEvent.TrackUnmuted: ${e.message}`);
       }
-      this.emit(RoomEvent.TrackUnmuted, publication, participant);
     } else if (ev.case == 'activeSpeakersChanged') {
-      const activeSpeakers = ev.value.participantIdentities.map((identity) =>
-        this.requireParticipantByIdentity(identity),
-      );
-      this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
+      try {
+        const activeSpeakers = ev.value.participantIdentities.map((identity) =>
+          this.requireParticipantByIdentity(identity),
+        );
+        this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
+      } catch (e: any) {
+        console.warn(`RoomEvent.ActiveSpeakersChanged: ${e.message}`);
+      }
     } else if (ev.case == 'roomMetadataChanged') {
-      this.info!.metadata = ev.value.metadata;
-      this.emit(RoomEvent.RoomMetadataChanged, this.info!.metadata!);
+      this.info.metadata = ev.value.metadata ?? '';
+      this.emit(RoomEvent.RoomMetadataChanged, this.info.metadata);
     } else if (ev.case == 'participantMetadataChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
-      participant.info.metadata = ev.value.metadata;
-      this.emit(RoomEvent.ParticipantMetadataChanged, participant.metadata, participant);
+      try {
+        const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
+        participant.info.metadata = ev.value.metadata;
+        this.emit(RoomEvent.ParticipantMetadataChanged, participant.metadata, participant);
+      } catch (e: any) {
+        console.warn(`RoomEvent.ParticipantMetadataChanged: ${e.message}`);
+      }
     } else if (ev.case == 'participantNameChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
-      participant.info.name = ev.value.name;
-      this.emit(RoomEvent.ParticipantNameChanged, participant.name!, participant);
+      try {
+        const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
+        participant.info.name = ev.value.name;
+        this.emit(RoomEvent.ParticipantNameChanged, participant.name!, participant);
+      } catch (e: any) {
+        console.warn(`RoomEvent.ParticipantNameChanged: ${e.message}`);
+      }
     } else if (ev.case == 'participantAttributesChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
-      participant.info.attributes = ev.value.attributes.reduce(
-        (acc, value) => {
-          acc[value.key!] = value.value!;
-          return acc;
-        },
-        {} as Record<string, string>,
-      );
-      if (Object.keys(ev.value.changedAttributes).length > 0) {
-        const changedAttributes = ev.value.changedAttributes.reduce(
+      try {
+        const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
+        participant.info.attributes = ev.value.attributes.reduce(
           (acc, value) => {
             acc[value.key!] = value.value!;
             return acc;
           },
           {} as Record<string, string>,
         );
-        this.emit(RoomEvent.ParticipantAttributesChanged, changedAttributes, participant);
+        if (Object.keys(ev.value.changedAttributes).length > 0) {
+          const changedAttributes = ev.value.changedAttributes.reduce(
+            (acc, value) => {
+              acc[value.key!] = value.value!;
+              return acc;
+            },
+            {} as Record<string, string>,
+          );
+          this.emit(RoomEvent.ParticipantAttributesChanged, changedAttributes, participant);
+        }
+      } catch (e: any) {
+        console.warn(`RoomEvent.ParticipantAttributesChanged: ${e.message}`);
       }
     } else if (ev.case == 'connectionQualityChanged') {
-      const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
-      this.emit(RoomEvent.ConnectionQualityChanged, ev.value.quality!, participant);
+      try {
+        const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
+        this.emit(RoomEvent.ConnectionQualityChanged, ev.value.quality!, participant);
+      } catch (e: any) {
+        console.warn(`RoomEvent.ConnectionQualityChanged: ${e.message}`);
+      }
     } else if (ev.case == 'chatMessage') {
       const participant = this.retrieveParticipantByIdentity(ev.value.participantIdentity!);
       const { id, message: messageText, timestamp, editTimestamp, generated } = ev.value.message!;
@@ -515,6 +603,17 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
           participant.info = info;
         }
       }
+    } else if (ev.case === 'participantEncryptionStatusChanged') {
+      try {
+        const participant = this.requireParticipantByIdentity(ev.value.participantIdentity!);
+        this.emit(
+          RoomEvent.ParticipantEncryptionStatusChanged,
+          !!ev.value.isEncrypted,
+          participant,
+        );
+      } catch (e: any) {
+        console.warn(`RoomEvent.ParticipantEncryptionStatusChanged: ${e.message}`);
+      }
     }
   };
 
@@ -716,12 +815,14 @@ export type RoomCallbacks = {
     changedAttributes: Record<string, string>,
     participant: Participant,
   ) => void;
+  participantEncryptionStatusChanged: (isEncrypted: boolean, participant: Participant) => void;
   connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void;
   dataReceived: (
     payload: Uint8Array,
     participant?: RemoteParticipant,
     kind?: DataPacketKind,
     topic?: string,
+    encryptionType?: EncryptionType,
   ) => void;
   chatMessage: (message: ChatMessage, participant?: Participant) => void;
   dtmfReceived: (code: number, digit: string, participant: RemoteParticipant) => void;
@@ -755,6 +856,7 @@ export enum RoomEvent {
   ParticipantMetadataChanged = 'participantMetadataChanged',
   ParticipantNameChanged = 'participantNameChanged',
   ParticipantAttributesChanged = 'participantAttributesChanged',
+  ParticipantEncryptionStatusChanged = 'participantEncryptionStatusChanged',
   ConnectionQualityChanged = 'connectionQualityChanged',
   DataReceived = 'dataReceived',
   ChatMessage = 'chatMessage',

package/src/version.ts

@@ -1 +1 @@
-export const SDK_VERSION = "0.13.20";
+export const SDK_VERSION = "0.13.22";