livekit-client 2.3.1 → 2.4.0

package/src/room/participant/LocalParticipant.ts

@@ -3,6 +3,7 @@ import {
   DataPacket,
   DataPacket_Kind,
   Encryption_Type,
+  ErrorResponse,
   ParticipantInfo,
   ParticipantPermission,
   SimulcastCodec,
@@ -14,7 +15,13 @@ import type { InternalRoomOptions } from '../../options';
 import { PCTransportState } from '../PCTransportManager';
 import type RTCEngine from '../RTCEngine';
 import { defaultVideoCodec } from '../defaults';
-import { DeviceUnsupportedError, TrackInvalidError, UnexpectedConnectionState } from '../errors';
+import {
+  DeviceUnsupportedError,
+  LivekitError,
+  SignalRequestError,
+  TrackInvalidError,
+  UnexpectedConnectionState,
+} from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalTrack from '../track/LocalTrack';
@@ -46,6 +53,7 @@ import {
   isSVCCodec,
   isSafari17,
   isWeb,
+  sleep,
   supportsAV1,
   supportsVP9,
 } from '../utils';
@@ -92,6 +100,15 @@ export default class LocalParticipant extends Participant {
 
   private reconnectFuture?: Future<void>;
 
+  private pendingSignalRequests: Map<
+    number,
+    {
+      resolve: (arg: any) => void;
+      reject: (reason: LivekitError) => void;
+      values: Partial<Record<keyof LocalParticipant, any>>;
+    }
+  >;
+
   /** @internal */
   constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions) {
     super(sid, identity, undefined, undefined, {
@@ -105,6 +122,7 @@ export default class LocalParticipant extends Participant {
     this.roomOptions = options;
     this.setupEngine(engine);
     this.activeDeviceMap = new Map();
+    this.pendingSignalRequests = new Map();
   }
 
   get lastCameraError(): Error | undefined {
@@ -158,7 +176,8 @@ export default class LocalParticipant extends Participant {
       .on(EngineEvent.Resuming, this.handleReconnecting)
       .on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished)
       .on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate)
-      .on(EngineEvent.Disconnected, this.handleDisconnected);
+      .on(EngineEvent.Disconnected, this.handleDisconnected)
+      .on(EngineEvent.SignalRequestError, this.handleSignalRequestError);
   }
 
   private handleReconnecting = () => {
@@ -181,26 +200,89 @@ export default class LocalParticipant extends Participant {
     }
   };
 
+  private handleSignalRequestError = (error: ErrorResponse) => {
+    const { requestId, reason, message } = error;
+    const failedRequest = this.pendingSignalRequests.get(requestId);
+    if (failedRequest) {
+      failedRequest.reject(new SignalRequestError(message, reason));
+      this.pendingSignalRequests.delete(requestId);
+    }
+  };
+
   /**
    * Sets and updates the metadata of the local participant.
-   * The change does not take immediate effect.
-   * If successful, a `ParticipantEvent.MetadataChanged` event will be emitted on the local participant.
    * Note: this requires `canUpdateOwnMetadata` permission.
+   * method will throw if the user doesn't have the required permissions
    * @param metadata
    */
-  setMetadata(metadata: string): void {
-    this.engine.client.sendUpdateLocalMetadata(metadata, this.name ?? '');
+  async setMetadata(metadata: string): Promise<void> {
+    await this.requestMetadataUpdate({ metadata });
   }
 
   /**
    * Sets and updates the name of the local participant.
-   * The change does not take immediate effect.
-   * If successful, a `ParticipantEvent.ParticipantNameChanged` event will be emitted on the local participant.
    * Note: this requires `canUpdateOwnMetadata` permission.
+   * method will throw if the user doesn't have the required permissions
    * @param metadata
    */
-  setName(name: string): void {
-    this.engine.client.sendUpdateLocalMetadata(this.metadata ?? '', name);
+  async setName(name: string): Promise<void> {
+    await this.requestMetadataUpdate({ name });
+  }
+
+  /**
+   * Set or update participant attributes. It will make updates only to keys that
+   * are present in `attributes`, and will not override others.
+   * Note: this requires `canUpdateOwnMetadata` permission.
+   * @param attributes attributes to update
+   */
+  async setAttributes(attributes: Record<string, string>) {
+    await this.requestMetadataUpdate({ attributes });
+  }
+
+  private async requestMetadataUpdate({
+    metadata,
+    name,
+    attributes,
+  }: {
+    metadata?: string;
+    name?: string;
+    attributes?: Record<string, string>;
+  }) {
+    return new Promise<void>(async (resolve, reject) => {
+      try {
+        let isRejected = false;
+        const requestId = await this.engine.client.sendUpdateLocalMetadata(
+          metadata ?? this.metadata ?? '',
+          name ?? this.name ?? '',
+          attributes,
+        );
+        const startTime = performance.now();
+        this.pendingSignalRequests.set(requestId, {
+          resolve,
+          reject: (error: LivekitError) => {
+            reject(error);
+            isRejected = true;
+          },
+          values: { name, metadata, attributes },
+        });
+        while (performance.now() - startTime < 5_000 && !isRejected) {
+          if (
+            (!name || this.name === name) &&
+            (!metadata || this.metadata === metadata) &&
+            (!attributes ||
+              Object.entries(attributes).every(([key, value]) => this.attributes[key] === value))
+          ) {
+            this.pendingSignalRequests.delete(requestId);
+            resolve();
+            return;
+          }
+          await sleep(50);
+        }
+        reject(new SignalRequestError('Request to update local metadata timed out'));
+      } catch (e: any) {
+        if (e instanceof Error) reject(e);
+      }
+    });
   }
 
   /**
@@ -1014,6 +1096,16 @@ export default class LocalParticipant extends Participant {
     track: LocalTrack | MediaStreamTrack,
     stopOnUnpublish?: boolean,
   ): Promise<LocalTrackPublication | undefined> {
+    if (track instanceof LocalTrack) {
+      const publishPromise = this.pendingPublishPromises.get(track);
+      if (publishPromise) {
+        this.log.info('awaiting publish promise before attempting to unpublish', {
+          ...this.logContext,
+          ...getLogContextFromTrack(track),
+        });
+        await publishPromise;
+      }
+    }
     // look through all published tracks to find the right ones
     const publication = this.getPublicationForTrack(track);
 

package/src/room/participant/Participant.ts

@@ -18,6 +18,7 @@ import type RemoteTrack from '../track/RemoteTrack';
 import type RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
+import { diffAttributes } from '../track/utils';
 import type { LoggerOptions, TranscriptionSegment } from '../types';
 
 export enum ConnectionQuality {
@@ -77,6 +78,8 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   /** client metadata, opaque to livekit */
   metadata?: string;
 
+  private _attributes: Record<string, string>;
+
   lastSpokeAt?: Date | undefined;
 
   permissions?: ParticipantPermission;
@@ -112,6 +115,11 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     return this._kind;
   }
 
+  /** participant attributes, similar to metadata, but as a key/value map */
+  get attributes(): Readonly<Record<string, string>> {
+    return Object.freeze({ ...this._attributes });
+  }
+
   /** @internal */
   constructor(
     sid: string,
@@ -135,6 +143,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     this.videoTrackPublications = new Map();
     this.trackPublications = new Map();
     this._kind = kind;
+    this._attributes = {};
   }
 
   getTrackPublications(): TrackPublication[] {
@@ -214,6 +223,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     this.sid = info.sid;
     this._setName(info.name);
     this._setMetadata(info.metadata);
+    this._setAttributes(info.attributes);
     if (info.permission) {
       this.setPermissions(info.permission);
     }
@@ -245,6 +255,18 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     }
   }
 
+  /**
+   * Updates metadata from server
+   **/
+  private _setAttributes(attributes: Record<string, string>) {
+    const diff = diffAttributes(attributes, this.attributes);
+    this._attributes = attributes;
+
+    if (Object.keys(diff).length > 0) {
+      this.emit(ParticipantEvent.AttributesChanged, diff);
+    }
+  }
+
   /** @internal */
   setPermissions(permissions: ParticipantPermission): boolean {
     const prevPermissions = this.permissions;
@@ -363,4 +385,5 @@ export type ParticipantEventCallbacks = {
     publication: RemoteTrackPublication,
     status: TrackPublication.SubscriptionStatus,
   ) => void;
+  attributesChanged: (changedAttributes: Record<string, string>) => void;
 };

package/src/room/track/Track.ts

@@ -129,7 +129,7 @@ export abstract class Track<
     if (this.kind === Track.Kind.Video) {
       elementType = 'video';
     }
-    if (this.attachedElements.length === 0 && Track.Kind.Video) {
+    if (this.attachedElements.length === 0 && this.kind === Track.Kind.Video) {
       this.addAppVisibilityListener();
     }
     if (!element) {

package/src/room/track/utils.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { AudioCaptureOptions, VideoCaptureOptions, VideoPresets } from './options';
-import { constraintsForOptions, mergeDefaultOptions } from './utils';
+import { constraintsForOptions, diffAttributes, mergeDefaultOptions } from './utils';
 
 describe('mergeDefaultOptions', () => {
   const audioDefaults: AudioCaptureOptions = {
@@ -109,3 +109,37 @@ describe('constraintsForOptions', () => {
     expect(videoOpts.aspectRatio).toEqual(VideoPresets.h720.resolution.aspectRatio);
   });
 });
+
+describe('diffAttributes', () => {
+  it('detects changed values', () => {
+    const oldValues: Record<string, string> = { a: 'value', b: 'initial', c: 'value' };
+    const newValues: Record<string, string> = { a: 'value', b: 'updated', c: 'value' };
+
+    const diff = diffAttributes(oldValues, newValues);
+    expect(Object.keys(diff).length).toBe(1);
+    expect(diff.b).toBe('updated');
+  });
+  it('detects new values', () => {
+    const newValues: Record<string, string> = { a: 'value', b: 'value', c: 'value' };
+    const oldValues: Record<string, string> = { a: 'value', b: 'value' };
+
+    const diff = diffAttributes(oldValues, newValues);
+    expect(Object.keys(diff).length).toBe(1);
+    expect(diff.c).toBe('value');
+  });
+  it('detects deleted values as empty strings', () => {
+    const newValues: Record<string, string> = { a: 'value', b: 'value' };
+    const oldValues: Record<string, string> = { a: 'value', b: 'value', c: 'value' };
+
+    const diff = diffAttributes(oldValues, newValues);
+    expect(Object.keys(diff).length).toBe(1);
+    expect(diff.c).toBe('');
+  });
+  it('compares with undefined values', () => {
+    const newValues: Record<string, string> = { a: 'value', b: 'value' };
+
+    const diff = diffAttributes(undefined, newValues);
+    expect(Object.keys(diff).length).toBe(2);
+    expect(diff.a).toBe('value');
+  });
+});

package/src/room/track/utils.ts

@@ -243,3 +243,25 @@ export function getLogContextFromTrack(track: Track | TrackPublication): Record<
 export function supportsSynchronizationSources(): boolean {
   return typeof RTCRtpReceiver !== 'undefined' && 'getSynchronizationSources' in RTCRtpReceiver;
 }
+
+export function diffAttributes(
+  oldValues: Record<string, string> | undefined,
+  newValues: Record<string, string> | undefined,
+) {
+  if (oldValues === undefined) {
+    oldValues = {};
+  }
+  if (newValues === undefined) {
+    newValues = {};
+  }
+  const allKeys = [...Object.keys(newValues), ...Object.keys(oldValues)];
+  const diff: Record<string, string> = {};
+
+  for (const key of allKeys) {
+    if (oldValues[key] !== newValues[key]) {
+      diff[key] = newValues[key] ?? '';
+    }
+  }
+
+  return diff;
+}