livekit-client 2.5.10 → 2.6.0

package/src/room/PCTransport.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import type { MediaDescription } from 'sdp-transform';
+import type { MediaDescription, SessionDescription } from 'sdp-transform';
 import { parse, write } from 'sdp-transform';
 import { debounce } from 'ts-debounce';
 import log, { LoggerNames, getLogger } from '../logger';
@@ -48,6 +48,8 @@ export default class PCTransport extends EventEmitter {
 
   private loggerOptions: LoggerOptions;
 
+  private ddExtID = 0;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -288,7 +290,7 @@ export default class PCTransport extends EventEmitter {
           }
 
           if (isSVCCodec(trackbr.codec)) {
-            ensureVideoDDExtensionForSVC(media);
+            this.ensureVideoDDExtensionForSVC(media, sdpParsed);
           }
 
           // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
@@ -503,6 +505,44 @@ export default class PCTransport extends EventEmitter {
       throw new NegotiationError(msg);
     }
   }
+
+  private ensureVideoDDExtensionForSVC(
+    media: {
+      type: string;
+      port: number;
+      protocol: string;
+      payloads?: string | undefined;
+    } & MediaDescription,
+    sdp: SessionDescription,
+  ) {
+    const ddFound = media.ext?.some((ext): boolean => {
+      if (ext.uri === ddExtensionURI) {
+        return true;
+      }
+      return false;
+    });
+
+    if (!ddFound) {
+      if (this.ddExtID === 0) {
+        let maxID = 0;
+        sdp.media.forEach((m) => {
+          if (m.type !== 'video') {
+            return;
+          }
+          m.ext?.forEach((ext) => {
+            if (ext.value > maxID) {
+              maxID = ext.value;
+            }
+          });
+        });
+        this.ddExtID = maxID + 1;
+      }
+      media.ext?.push({
+        value: this.ddExtID,
+        uri: ddExtensionURI,
+      });
+    }
+  }
 }
 
 function ensureAudioNackAndStereo(
@@ -555,33 +595,6 @@ function ensureAudioNackAndStereo(
   }
 }
 
-function ensureVideoDDExtensionForSVC(
-  media: {
-    type: string;
-    port: number;
-    protocol: string;
-    payloads?: string | undefined;
-  } & MediaDescription,
-) {
-  let maxID = 0;
-  const ddFound = media.ext?.some((ext): boolean => {
-    if (ext.uri === ddExtensionURI) {
-      return true;
-    }
-    if (ext.value > maxID) {
-      maxID = ext.value;
-    }
-    return false;
-  });
-
-  if (!ddFound) {
-    media.ext?.push({
-      value: maxID + 1,
-      uri: ddExtensionURI,
-    });
-  }
-}
-
 function extractStereoAndNackAudioFromOffer(offer: RTCSessionDescriptionInit): {
   stereoMids: string[];
   nackMids: string[];

package/src/room/Room.ts

@@ -1414,6 +1414,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       participant.unpublishTrack(publication.trackSid, true);
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
+    this.localParticipant?.handleParticipantDisconnected(participant.identity);
   }
 
   // updates are sent only when there's a change to speaker ordering

package/src/room/participant/LocalParticipant.test.ts

@@ -0,0 +1,304 @@
+import { DataPacket, DataPacket_Kind } from '@livekit/protocol';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { InternalRoomOptions } from '../../options';
+import type RTCEngine from '../RTCEngine';
+import { RpcError } from '../rpc';
+import LocalParticipant from './LocalParticipant';
+import { ParticipantKind } from './Participant';
+import RemoteParticipant from './RemoteParticipant';
+
+describe('LocalParticipant', () => {
+  describe('registerRpcMethod', () => {
+    let localParticipant: LocalParticipant;
+    let mockEngine: RTCEngine;
+    let mockRoomOptions: InternalRoomOptions;
+    let mockSendDataPacket: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+      mockSendDataPacket = vi.fn();
+      mockEngine = {
+        client: {
+          sendUpdateLocalMetadata: vi.fn(),
+        },
+        on: vi.fn().mockReturnThis(),
+        sendDataPacket: mockSendDataPacket,
+      } as unknown as RTCEngine;
+
+      mockRoomOptions = {} as InternalRoomOptions;
+
+      localParticipant = new LocalParticipant(
+        'test-sid',
+        'test-identity',
+        mockEngine,
+        mockRoomOptions,
+      );
+    });
+
+    it('should register an RPC method handler', async () => {
+      const methodName = 'testMethod';
+      const handler = vi.fn().mockResolvedValue('test response');
+
+      localParticipant.registerRpcMethod(methodName, handler);
+
+      const mockCaller = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+
+      await localParticipant.handleIncomingRpcRequest(
+        mockCaller.identity,
+        'test-request-id',
+        methodName,
+        'test payload',
+        5000,
+        1,
+      );
+
+      expect(handler).toHaveBeenCalledWith({
+        requestId: 'test-request-id',
+        callerIdentity: mockCaller.identity,
+        payload: 'test payload',
+        responseTimeout: 5000,
+      });
+
+      // Check if sendDataPacket was called twice (once for ACK and once for response)
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+      // Check if the first call was for ACK
+      expect(mockSendDataPacket.mock.calls[0][0].value.case).toBe('rpcAck');
+      expect(mockSendDataPacket.mock.calls[0][1]).toBe(DataPacket_Kind.RELIABLE);
+
+      // Check if the second call was for response
+      expect(mockSendDataPacket.mock.calls[1][0].value.case).toBe('rpcResponse');
+      expect(mockSendDataPacket.mock.calls[1][1]).toBe(DataPacket_Kind.RELIABLE);
+    });
+
+    it('should catch and transform unhandled errors in the RPC method handler', async () => {
+      const methodName = 'errorMethod';
+      const errorMessage = 'Test error';
+      const handler = vi.fn().mockRejectedValue(new Error(errorMessage));
+
+      localParticipant.registerRpcMethod(methodName, handler);
+
+      const mockCaller = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+
+      await localParticipant.handleIncomingRpcRequest(
+        mockCaller.identity,
+        'test-error-request-id',
+        methodName,
+        'test payload',
+        5000,
+        1,
+      );
+
+      expect(handler).toHaveBeenCalledWith({
+        requestId: 'test-error-request-id',
+        callerIdentity: mockCaller.identity,
+        payload: 'test payload',
+        responseTimeout: 5000,
+      });
+
+      // Check if sendDataPacket was called twice (once for ACK and once for error response)
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+      // Check if the second call was for error response
+      const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
+      expect(errorResponse.code).toBe(RpcError.ErrorCode.APPLICATION_ERROR);
+    });
+
+    it('should pass through RpcError thrown by the RPC method handler', async () => {
+      const methodName = 'rpcErrorMethod';
+      const errorCode = 101;
+      const errorMessage = 'some-error-message';
+      const handler = vi.fn().mockRejectedValue(new RpcError(errorCode, errorMessage));
+
+      localParticipant.registerRpcMethod(methodName, handler);
+
+      const mockCaller = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+
+      await localParticipant.handleIncomingRpcRequest(
+        mockCaller.identity,
+        'test-rpc-error-request-id',
+        methodName,
+        'test payload',
+        5000,
+        1,
+      );
+
+      expect(handler).toHaveBeenCalledWith({
+        requestId: 'test-rpc-error-request-id',
+        callerIdentity: mockCaller.identity,
+        payload: 'test payload',
+        responseTimeout: 5000,
+      });
+
+      // Check if sendDataPacket was called twice (once for ACK and once for error response)
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+      // Check if the second call was for error response
+      const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
+      expect(errorResponse.code).toBe(errorCode);
+      expect(errorResponse.message).toBe(errorMessage);
+    });
+  });
+
+  describe('performRpc', () => {
+    let localParticipant: LocalParticipant;
+    let mockRemoteParticipant: RemoteParticipant;
+    let mockEngine: RTCEngine;
+    let mockRoomOptions: InternalRoomOptions;
+    let mockSendDataPacket: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+      mockSendDataPacket = vi.fn();
+      mockEngine = {
+        client: {
+          sendUpdateLocalMetadata: vi.fn(),
+        },
+        on: vi.fn().mockReturnThis(),
+        sendDataPacket: mockSendDataPacket,
+      } as unknown as RTCEngine;
+
+      mockRoomOptions = {} as InternalRoomOptions;
+
+      localParticipant = new LocalParticipant(
+        'local-sid',
+        'local-identity',
+        mockEngine,
+        mockRoomOptions,
+      );
+
+      mockRemoteParticipant = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+    });
+
+    it('should send RPC request and receive successful response', async () => {
+      const method = 'testMethod';
+      const payload = 'testPayload';
+      const responsePayload = 'responsePayload';
+
+      mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
+        const requestId = packet.value.value.id;
+        setTimeout(() => {
+          localParticipant.handleIncomingRpcAck(requestId);
+          setTimeout(() => {
+            localParticipant.handleIncomingRpcResponse(requestId, responsePayload, null);
+          }, 10);
+        }, 10);
+      });
+
+      const result = await localParticipant.performRpc({
+        destinationIdentity: mockRemoteParticipant.identity,
+        method,
+        payload,
+      });
+
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
+      expect(result).toBe(responsePayload);
+    });
+
+    it('should handle RPC request timeout', async () => {
+      const method = 'timeoutMethod';
+      const payload = 'timeoutPayload';
+
+      const timeout = 50;
+
+      const resultPromise = localParticipant.performRpc({
+        destinationIdentity: mockRemoteParticipant.identity,
+        method,
+        payload,
+        responseTimeout: timeout,
+      });
+
+      mockSendDataPacket.mockImplementationOnce(() => {
+        return new Promise((resolve) => {
+          setTimeout(resolve, timeout + 10);
+        });
+      });
+
+      const startTime = Date.now();
+
+      await expect(resultPromise).rejects.toThrow('Response timeout');
+
+      const elapsedTime = Date.now() - startTime;
+      expect(elapsedTime).toBeGreaterThanOrEqual(timeout);
+      expect(elapsedTime).toBeLessThan(timeout + 50); // Allow some margin for test execution
+
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle RPC error response', async () => {
+      const method = 'errorMethod';
+      const payload = 'errorPayload';
+      const errorCode = 101;
+      const errorMessage = 'Test error message';
+
+      mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
+        const requestId = packet.value.value.id;
+        setTimeout(() => {
+          localParticipant.handleIncomingRpcAck(requestId);
+          localParticipant.handleIncomingRpcResponse(
+            requestId,
+            null,
+            new RpcError(errorCode, errorMessage),
+          );
+        }, 10);
+      });
+
+      await expect(
+        localParticipant.performRpc({
+          destinationIdentity: mockRemoteParticipant.identity,
+          method,
+          payload,
+        }),
+      ).rejects.toThrow(errorMessage);
+    });
+
+    it('should handle participant disconnection during RPC request', async () => {
+      const method = 'disconnectMethod';
+      const payload = 'disconnectPayload';
+
+      mockSendDataPacket.mockImplementationOnce(() => Promise.resolve());
+
+      const resultPromise = localParticipant.performRpc({
+        destinationIdentity: mockRemoteParticipant.identity,
+        method,
+        payload,
+      });
+
+      // Simulate a small delay before disconnection
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      localParticipant.handleParticipantDisconnected(mockRemoteParticipant.identity);
+
+      await expect(resultPromise).rejects.toThrow('Recipient disconnected');
+    });
+  });
+});