livekit-client 2.18.9 → 2.19.0

package/src/room/participant/LocalParticipant.ts

@@ -9,12 +9,10 @@ import {
   DataPacket_Kind,
   Encryption_Type,
   JoinResponse,
+  PacketTrailerFeature,
   ParticipantInfo,
   RequestResponse,
   RequestResponse_Reason,
-  RpcAck,
-  RpcRequest,
-  RpcResponse,
   SimulcastCodec,
   SipDTMF,
   SubscribedQualityUpdate,
@@ -25,6 +23,12 @@ import {
 } from '@livekit/protocol';
 import { SignalConnectionState } from '../../api/SignalClient';
 import type { InternalRoomOptions } from '../../options';
+import {
+  getPacketTrailerFeatures,
+  getPacketTrailerPublishOptions,
+  hasPacketTrailerPublishOptions,
+  isPacketTrailerSupported,
+} from '../../packetTrailer/utils';
 import TypedPromise from '../../utils/TypedPromise';
 import { PCTransportState } from '../PCTransportManager';
 import type RTCEngine from '../RTCEngine';
@@ -47,11 +51,11 @@ import {
 } from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
 import {
-  MAX_PAYLOAD_BYTES,
   type PerformRpcParams,
+  RpcClientManager,
   RpcError,
   type RpcInvocationData,
-  byteLength,
+  RpcServerManager,
 } from '../rpc';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalTrack from '../track/LocalTrack';
@@ -87,7 +91,6 @@ import {
 } from '../types';
 import {
   Future,
-  compareVersions,
   isAudioTrack,
   isE2EESimulcastSupported,
   isFireFox,
@@ -155,12 +158,14 @@ export default class LocalParticipant extends Participant {
 
   private firstActiveAgent?: RemoteParticipant;
 
-  private rpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>;
-
   private roomOutgoingDataStreamManager: OutgoingDataStreamManager;
 
   private roomOutgoingDataTrackManager: OutgoingDataTrackManager;
 
+  private rpcClientManager: RpcClientManager;
+
+  private rpcServerManager: RpcServerManager;
+
   private pendingSignalRequests: Map<
     number,
     {
@@ -172,25 +177,16 @@ export default class LocalParticipant extends Participant {
 
   private enabledPublishVideoCodecs: Codec[] = [];
 
-  private pendingAcks = new Map<string, { resolve: () => void; participantIdentity: string }>();
-
-  private pendingResponses = new Map<
-    string,
-    {
-      resolve: (payload: string | null, error: RpcError | null) => void;
-      participantIdentity: string;
-    }
-  >();
-
   /** @internal */
   constructor(
     sid: string,
     identity: string,
     engine: RTCEngine,
     options: InternalRoomOptions,
-    roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>,
     roomOutgoingDataStreamManager: OutgoingDataStreamManager,
     roomOutgoingDataTrackManager: OutgoingDataTrackManager,
+    rpcClientManager: RpcClientManager,
+    rpcServerManager: RpcServerManager,
   ) {
     super(sid, identity, undefined, undefined, undefined, {
       loggerName: options.loggerName,
@@ -208,9 +204,10 @@ export default class LocalParticipant extends Participant {
       ['audiooutput', 'default'],
     ]);
     this.pendingSignalRequests = new Map();
-    this.rpcHandlers = roomRpcHandlers;
     this.roomOutgoingDataStreamManager = roomOutgoingDataStreamManager;
     this.roomOutgoingDataTrackManager = roomOutgoingDataTrackManager;
+    this.rpcClientManager = rpcClientManager;
+    this.rpcServerManager = rpcServerManager;
   }
 
   get lastCameraError(): Error | undefined {
@@ -270,8 +267,7 @@ export default class LocalParticipant extends Participant {
       .on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished)
       .on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate)
       .on(EngineEvent.Closing, this.handleClosing)
-      .on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse)
-      .on(EngineEvent.DataPacketReceived, this.handleDataPacket);
+      .on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse);
   }
 
   private handleReconnecting = () => {
@@ -343,7 +339,7 @@ export default class LocalParticipant extends Participant {
             break;
           default:
             error = DataTrackPublishError.unknown(response.reason, response.message);
-            return;
+            break;
         }
 
         this.roomOutgoingDataTrackManager.receivedSfuPublishResponse(
@@ -355,27 +351,6 @@ export default class LocalParticipant extends Participant {
     }
   };
 
-  private handleDataPacket = (packet: DataPacket) => {
-    switch (packet.value.case) {
-      case 'rpcResponse':
-        let rpcResponse = packet.value.value as RpcResponse;
-        let payload: string | null = null;
-        let error: RpcError | null = null;
-
-        if (rpcResponse.value.case === 'payload') {
-          payload = rpcResponse.value.value;
-        } else if (rpcResponse.value.case === 'error') {
-          error = RpcError.fromProto(rpcResponse.value.value);
-        }
-        this.handleIncomingRpcResponse(rpcResponse.requestId, payload, error);
-        break;
-      case 'rpcAck':
-        let rpcAck = packet.value.value as RpcAck;
-        this.handleIncomingRpcAck(rpcAck.requestId);
-        break;
-    }
-  };
-
   /**
    * Sets and updates the metadata of the local participant.
    * Note: this requires `canUpdateOwnMetadata` permission.
@@ -1109,6 +1084,8 @@ export default class LocalParticipant extends Participant {
     if (isLocalAudioTrack(track) && track.hasPreConnectBuffer) {
       audioFeatures.push(AudioTrackFeature.TF_PRECONNECT_BUFFER);
     }
+    const packetTrailerFeatures: PacketTrailerFeature[] =
+      this.normalizeRequestedPacketTrailerOptions(track, opts);
 
     // create track publication from track
     const req = new AddTrackRequest({
@@ -1125,15 +1102,13 @@ export default class LocalParticipant extends Participant {
       stream: opts?.stream,
       backupCodecPolicy: opts?.backupCodecPolicy as BackupCodecPolicy,
       audioFeatures,
+      packetTrailerFeatures,
     });
 
     // compute encodings and layers for video
     let encodings: RTCRtpEncodingParameters[] | undefined;
     if (track.kind === Track.Kind.Video) {
-      let dims: Track.Dimensions = {
-        width: 0,
-        height: 0,
-      };
+      let dims: Track.Dimensions;
       try {
         dims = await track.waitForDimensions();
       } catch (e) {
@@ -1240,6 +1215,9 @@ export default class LocalParticipant extends Participant {
       }
 
       track.sender = await this.engine.createSender(track, opts, encodings);
+      if (isLocalVideoTrack(track)) {
+        track.publishOptions = opts;
+      }
       this.emit(ParticipantEvent.LocalSenderCreated, track.sender, track);
 
       if (isLocalVideoTrack(track)) {
@@ -1307,7 +1285,7 @@ export default class LocalParticipant extends Participant {
         reject(err);
       }
     });
-    if (this.enabledPublishVideoCodecs.length > 0) {
+    if (this.enabledPublishVideoCodecs.length > 0 && packetTrailerFeatures.length === 0) {
       const rets = await Promise.all([addTrackPromise, negotiate()]);
       ti = rets[0];
     } else {
@@ -1438,6 +1416,34 @@ export default class LocalParticipant extends Participant {
     return publication;
   }
 
+  private canPublishPacketTrailer() {
+    return !!(
+      this.roomOptions.e2ee ||
+      this.roomOptions.encryption ||
+      isPacketTrailerSupported(this.roomOptions.packetTrailer)
+    );
+  }
+
+  private normalizeRequestedPacketTrailerOptions(track: LocalTrack, opts: TrackPublishOptions) {
+    if (track.kind !== Track.Kind.Video || !hasPacketTrailerPublishOptions(opts.packetTrailer)) {
+      opts.packetTrailer = undefined;
+      return [];
+    }
+
+    if (!this.canPublishPacketTrailer()) {
+      this.log.warn('packet trailer transform not supported; not advertising features', {
+        ...this.logContext,
+        ...getLogContextFromTrack(track),
+      });
+      opts.packetTrailer = undefined;
+      return [];
+    }
+
+    const features = getPacketTrailerFeatures(opts.packetTrailer);
+    opts.packetTrailer = getPacketTrailerPublishOptions(features);
+    return features;
+  }
+
   override get isLocal(): boolean {
     return true;
   }
@@ -1490,12 +1496,15 @@ export default class LocalParticipant extends Participant {
     if (!simulcastTrack) {
       return;
     }
+    const packetTrailerFeatures = this.normalizeRequestedPacketTrailerOptions(track, opts);
+
     const req = new AddTrackRequest({
       cid: simulcastTrack.mediaStreamTrack.id,
       type: Track.kindToProto(track.kind),
       muted: track.isMuted,
       source: Track.sourceToProto(track.source),
       sid: track.sid,
+      packetTrailerFeatures,
       simulcastCodecs: [
         {
           codec: opts.videoCodec,
@@ -1703,7 +1712,7 @@ export default class LocalParticipant extends Participant {
    * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
    * @param options optionally specify a `reliable`, `topic` and `destination`
    */
-  async publishData(data: Uint8Array, options: DataPublishOptions = {}): Promise<void> {
+  async publishData(data: NonSharedUint8Array, options: DataPublishOptions = {}): Promise<void> {
     const kind = options.reliable ? DataChannelKind.RELIABLE : DataChannelKind.LOSSY;
     const dataPacketKind = options.reliable ? DataPacket_Kind.RELIABLE : DataPacket_Kind.LOSSY;
     const destinationIdentities = options.destinationIdentities;
@@ -1842,69 +1851,9 @@ export default class LocalParticipant extends Participant {
    * @returns A promise that resolves with the response payload or rejects with an error.
    * @throws Error on failure. Details in `message`.
    */
-  performRpc({
-    destinationIdentity,
-    method,
-    payload,
-    responseTimeout = 15000,
-  }: PerformRpcParams): TypedPromise<string, RpcError> {
-    const maxRoundTripLatency = 7000;
-    const minEffectiveTimeout = maxRoundTripLatency + 1000;
-
-    return new TypedPromise<string, RpcError>(async (resolve, reject) => {
-      if (byteLength(payload) > MAX_PAYLOAD_BYTES) {
-        reject(RpcError.builtIn('REQUEST_PAYLOAD_TOO_LARGE'));
-        return;
-      }
-
-      if (
-        this.engine.latestJoinResponse?.serverInfo?.version &&
-        compareVersions(this.engine.latestJoinResponse?.serverInfo?.version, '1.8.0') < 0
-      ) {
-        reject(RpcError.builtIn('UNSUPPORTED_SERVER'));
-        return;
-      }
-
-      const effectiveTimeout = Math.max(responseTimeout, minEffectiveTimeout);
-      const id = crypto.randomUUID();
-      await this.publishRpcRequest(destinationIdentity, id, method, payload, effectiveTimeout);
-
-      const ackTimeoutId = setTimeout(() => {
-        this.pendingAcks.delete(id);
-        reject(RpcError.builtIn('CONNECTION_TIMEOUT'));
-        this.pendingResponses.delete(id);
-        clearTimeout(responseTimeoutId);
-      }, maxRoundTripLatency);
-
-      this.pendingAcks.set(id, {
-        resolve: () => {
-          clearTimeout(ackTimeoutId);
-        },
-        participantIdentity: destinationIdentity,
-      });
-
-      const responseTimeoutId = setTimeout(() => {
-        this.pendingResponses.delete(id);
-        reject(RpcError.builtIn('RESPONSE_TIMEOUT'));
-      }, responseTimeout);
-
-      this.pendingResponses.set(id, {
-        resolve: (responsePayload: string | null, responseError: RpcError | null) => {
-          clearTimeout(responseTimeoutId);
-          if (this.pendingAcks.has(id)) {
-            this.log.warn('RPC response received before ack', id);
-            this.pendingAcks.delete(id);
-            clearTimeout(ackTimeoutId);
-          }
-
-          if (responseError) {
-            reject(responseError);
-          } else {
-            resolve(responsePayload ?? '');
-          }
-        },
-        participantIdentity: destinationIdentity,
-      });
+  performRpc(params: PerformRpcParams): TypedPromise<string, RpcError> {
+    return this.rpcClientManager.performRpc(params).then(([_id, completionPromise]) => {
+      return completionPromise;
     });
   }
 
@@ -1912,20 +1861,14 @@ export default class LocalParticipant extends Participant {
    * @deprecated use `room.registerRpcMethod` instead
    */
   registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>) {
-    if (this.rpcHandlers.has(method)) {
-      this.log.warn(
-        `you're overriding the RPC handler for method ${method}, in the future this will throw an error`,
-      );
-    }
-
-    this.rpcHandlers.set(method, handler);
+    this.rpcServerManager.registerRpcMethod(method, handler);
   }
 
   /**
    * @deprecated use `room.unregisterRpcMethod` instead
    */
   unregisterRpcMethod(method: string) {
-    this.rpcHandlers.delete(method);
+    this.rpcServerManager.unregisterRpcMethod(method);
   }
 
   /**
@@ -1956,72 +1899,6 @@ export default class LocalParticipant extends Participant {
     }
   }
 
-  private handleIncomingRpcAck(requestId: string) {
-    const handler = this.pendingAcks.get(requestId);
-    if (handler) {
-      handler.resolve();
-      this.pendingAcks.delete(requestId);
-    } else {
-      console.error('Ack received for unexpected RPC request', requestId);
-    }
-  }
-
-  private handleIncomingRpcResponse(
-    requestId: string,
-    payload: string | null,
-    error: RpcError | null,
-  ) {
-    const handler = this.pendingResponses.get(requestId);
-    if (handler) {
-      handler.resolve(payload, error);
-      this.pendingResponses.delete(requestId);
-    } else {
-      console.error('Response received for unexpected RPC request', requestId);
-    }
-  }
-
-  /** @internal */
-  private async publishRpcRequest(
-    destinationIdentity: string,
-    requestId: string,
-    method: string,
-    payload: string,
-    responseTimeout: number,
-  ) {
-    const packet = new DataPacket({
-      destinationIdentities: [destinationIdentity],
-      kind: DataPacket_Kind.RELIABLE,
-      value: {
-        case: 'rpcRequest',
-        value: new RpcRequest({
-          id: requestId,
-          method,
-          payload,
-          responseTimeoutMs: responseTimeout,
-          version: 1,
-        }),
-      },
-    });
-
-    await this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
-  }
-
-  /** @internal */
-  handleParticipantDisconnected(participantIdentity: string) {
-    for (const [id, { participantIdentity: pendingIdentity }] of this.pendingAcks) {
-      if (pendingIdentity === participantIdentity) {
-        this.pendingAcks.delete(id);
-      }
-    }
-
-    for (const [id, { participantIdentity: pendingIdentity, resolve }] of this.pendingResponses) {
-      if (pendingIdentity === participantIdentity) {
-        resolve(null, RpcError.builtIn('RECIPIENT_DISCONNECTED'));
-        this.pendingResponses.delete(id);
-      }
-    }
-  }
-
   /** @internal */
   setEnabledPublishCodecs(codecs: Codec[]) {
     this.enabledPublishVideoCodecs = codecs.filter(

package/src/room/participant/Participant.ts

@@ -413,7 +413,7 @@ export type ParticipantEventCallbacks = {
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   participantNameChanged: (name: string) => void;
   dataReceived: (
-    payload: Uint8Array,
+    payload: NonSharedUint8Array,
     kind: DataPacket_Kind,
     encryptionType?: Encryption_Type,
   ) => void;

package/src/room/participant/RemoteParticipant.ts

@@ -6,6 +6,7 @@ import type {
 } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
 import { DeferrableMap } from '../../utils/deferrable-map';
+import { CLIENT_PROTOCOL_DEFAULT } from '../../version';
 import RemoteDataTrack from '../data-track/RemoteDataTrack';
 import type IncomingDataTrackManager from '../data-track/incoming/IncomingDataTrackManager';
 import { DataTrackInfo } from '../data-track/types';
@@ -41,6 +42,11 @@ export default class RemoteParticipant extends Participant {
 
   signalClient: SignalClient;
 
+  /** A version number indicating the set of features that the report participant's client supports.
+   * @internal
+   **/
+  clientProtocol: number;
+
   private volumeMap: Map<Track.Source, number>;
 
   private audioOutput?: AudioOutputOptions;
@@ -65,6 +71,7 @@ export default class RemoteParticipant extends Participant {
         const info = DataTrackInfo.from(dti);
         return new RemoteDataTrack(info, manager, { publisherIdentity: pi.identity });
       }),
+      pi.clientProtocol,
     );
   }
 
@@ -87,6 +94,7 @@ export default class RemoteParticipant extends Participant {
     loggerOptions?: LoggerOptions,
     kind: ParticipantKind = ParticipantKind.STANDARD,
     remoteDataTracks: Array<RemoteDataTrack> = [],
+    clientProtocol: number = CLIENT_PROTOCOL_DEFAULT,
   ) {
     super(sid, identity || '', name, metadata, attributes, loggerOptions, kind);
     this.signalClient = signalClient;
@@ -99,6 +107,7 @@ export default class RemoteParticipant extends Participant {
       }),
     );
     this.volumeMap = new Map();
+    this.clientProtocol = clientProtocol;
   }
 
   protected addTrackPublication(publication: RemoteTrackPublication) {

package/src/room/participant/publishUtils.ts

@@ -194,7 +194,7 @@ export function computeVideoEncodings(
     return [videoEncoding];
   }
 
-  let presets: Array<VideoPreset> = [];
+  let presets: Array<VideoPreset>;
   if (isScreenShare) {
     presets =
       sortPresets(options?.screenShareSimulcastLayers) ??