livekit-client 2.9.9 → 2.11.0

package/src/api/utils.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { createRtcUrl, createValidateUrl } from './utils';
+
+describe('createRtcUrl', () => {
+  it('should create a basic RTC URL', () => {
+    const url = 'wss://example.com';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+    expect(result.toString()).toBe('wss://example.com/rtc');
+  });
+
+  it('should handle search parameters', () => {
+    const url = 'wss://example.com';
+    const searchParams = new URLSearchParams({
+      token: 'test-token',
+      room: 'test-room',
+    });
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc');
+    expect(parsedResult.searchParams.get('token')).toBe('test-token');
+    expect(parsedResult.searchParams.get('room')).toBe('test-room');
+  });
+
+  it('should handle ws protocol', () => {
+    const url = 'ws://example.com';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc');
+  });
+
+  it('should handle sub paths', () => {
+    const url = 'wss://example.com/sub/path';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/sub/path/rtc');
+  });
+
+  it('should handle sub paths with trailing slashes', () => {
+    const url = 'wss://example.com/sub/path/';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/sub/path/rtc');
+  });
+
+  it('should handle sub paths with url params', () => {
+    const url = 'wss://example.com/sub/path?param=value';
+    const searchParams = new URLSearchParams();
+    searchParams.set('token', 'test-token');
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/sub/path/rtc');
+    expect(parsedResult.searchParams.get('param')).toBe('value');
+    expect(parsedResult.searchParams.get('token')).toBe('test-token');
+  });
+});
+
+describe('createValidateUrl', () => {
+  it('should create a basic validate URL', () => {
+    const rtcUrl = createRtcUrl('wss://example.com', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+    expect(result.toString()).toBe('https://example.com/rtc/validate');
+  });
+
+  it('should handle search parameters', () => {
+    const rtcUrl = createRtcUrl(
+      'wss://example.com',
+      new URLSearchParams({
+        token: 'test-token',
+        room: 'test-room',
+      }),
+    );
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc/validate');
+    expect(parsedResult.searchParams.get('token')).toBe('test-token');
+    expect(parsedResult.searchParams.get('room')).toBe('test-room');
+  });
+
+  it('should handle ws protocol', () => {
+    const rtcUrl = createRtcUrl('ws://example.com', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc/validate');
+  });
+
+  it('should preserve the original path', () => {
+    const rtcUrl = createRtcUrl('wss://example.com/some/path', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/some/path/rtc/validate');
+  });
+
+  it('should handle sub paths with trailing slashes', () => {
+    const rtcUrl = createRtcUrl('wss://example.com/sub/path/', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/sub/path/rtc/validate');
+  });
+});

package/src/api/utils.ts

@@ -0,0 +1,23 @@
+import { toHttpUrl } from '../room/utils';
+
+export function createRtcUrl(url: string, searchParams: URLSearchParams) {
+  const urlObj = new URL(url);
+  searchParams.forEach((value, key) => {
+    urlObj.searchParams.set(key, value);
+  });
+  return appendUrlPath(urlObj, 'rtc');
+}
+
+export function createValidateUrl(rtcWsUrl: string) {
+  const urlObj = new URL(toHttpUrl(rtcWsUrl));
+  return appendUrlPath(urlObj, 'validate');
+}
+
+function ensureTrailingSlash(path: string) {
+  return path.endsWith('/') ? path : `${path}/`;
+}
+
+function appendUrlPath(urlObj: URL, path: string) {
+  urlObj.pathname = `${ensureTrailingSlash(urlObj.pathname)}${path}`;
+  return urlObj.toString();
+}

package/src/room/DeviceManager.ts

@@ -57,7 +57,7 @@ export default class DeviceManager {
       if (isDummyDeviceOrEmpty) {
         const permissionsToAcquire = {
           video: kind !== 'audioinput' && kind !== 'audiooutput',
-          audio: kind !== 'videoinput' && { deviceId: 'default' },
+          audio: kind !== 'videoinput' && { deviceId: { ideal: 'default' } },
         };
         const stream = await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
         devices = await navigator.mediaDevices.enumerateDevices();

package/src/room/RTCEngine.ts

@@ -248,6 +248,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
 
       this.clientConfiguration = joinResponse.clientConfiguration;
+      // emit signal connected event after a short delay to allow for join response to be processed on room
+      setTimeout(() => {
+        this.emit(EngineEvent.SignalConnected);
+      }, 10);
       return joinResponse;
     } catch (e) {
       if (e instanceof ConnectionError) {
@@ -1500,6 +1504,7 @@ export type EngineEventCallbacks = {
   remoteMute: (trackSid: string, muted: boolean) => void;
   offline: () => void;
   signalRequestResponse: (response: RequestResponse) => void;
+  signalConnected: () => void;
 };
 
 function supportOptionalDatachannel(protocol: number | undefined): boolean {

package/src/room/Room.ts

@@ -1280,7 +1280,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    *  `audiooutput` to set speaker for all incoming audio tracks
    * @param deviceId
    */
-  async switchActiveDevice(kind: MediaDeviceKind, deviceId: string, exact: boolean = false) {
+  async switchActiveDevice(kind: MediaDeviceKind, deviceId: string, exact: boolean = true) {
     let success = true;
     let needsUpdateWithoutTracks = false;
     const deviceConstraint = exact ? { exact: deviceId } : deviceId;

package/src/room/StreamWriter.ts

@@ -29,4 +29,4 @@ class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
 
 export class TextStreamWriter extends BaseStreamWriter<string, TextStreamInfo> {}
 
-export class BinaryStreamWriter extends BaseStreamWriter<Uint8Array, ByteStreamInfo> {}
+export class ByteStreamWriter extends BaseStreamWriter<Uint8Array, ByteStreamInfo> {}

package/src/room/defaults.ts

@@ -22,7 +22,7 @@ export const publishDefaults: TrackPublishDefaults = {
 } as const;
 
 export const audioDefaults: AudioCaptureOptions = {
-  deviceId: 'default',
+  deviceId: { ideal: 'default' },
   autoGainControl: true,
   echoCancellation: true,
   noiseSuppression: true,
@@ -30,7 +30,7 @@ export const audioDefaults: AudioCaptureOptions = {
 };
 
 export const videoDefaults: VideoCaptureOptions = {
-  deviceId: 'default',
+  deviceId: { ideal: 'default' },
   resolution: VideoPresets.h720.resolution,
 };
 

package/src/room/events.ts

@@ -562,6 +562,7 @@ export enum EngineEvent {
   LocalTrackSubscribed = 'localTrackSubscribed',
   Offline = 'offline',
   SignalRequestResponse = 'signalRequestResponse',
+  SignalConnected = 'signalConnected',
 }
 
 export enum TrackEvent {

package/src/room/participant/LocalParticipant.ts

@@ -1,5 +1,7 @@
+import { Mutex } from '@livekit/mutex';
 import {
   AddTrackRequest,
+  BackupCodecPolicy,
   ChatMessage as ChatMessageModel,
   Codec,
   DataPacket,
@@ -26,10 +28,11 @@ import {
   UserPacket,
   protoInt64,
 } from '@livekit/protocol';
+import { SignalConnectionState } from '../../api/SignalClient';
 import type { InternalRoomOptions } from '../../options';
 import { PCTransportState } from '../PCTransportManager';
 import type RTCEngine from '../RTCEngine';
-import { TextStreamWriter } from '../StreamWriter';
+import { ByteStreamWriter, TextStreamWriter } from '../StreamWriter';
 import { defaultVideoCodec } from '../defaults';
 import {
   DeviceUnsupportedError,
@@ -71,6 +74,7 @@ import {
   screenCaptureToDisplayMediaStreamOptions,
 } from '../track/utils';
 import {
+  type ByteStreamInfo,
   type ChatMessage,
   type DataPublishOptions,
   type SendTextOptions,
@@ -527,9 +531,11 @@ export default class LocalParticipant extends Participant {
               ...this.logContext,
               ...getLogContextFromTrack(localTrack),
             });
+
             publishPromises.push(this.publishTrack(localTrack, publishOptions));
           }
           const publishedTracks = await Promise.all(publishPromises);
+
           // for screen share publications including audio, this will only return the screen share publication, not the screen share audio one
           // revisit if we want to return an array of tracks instead for v2
           [track] = publishedTracks;
@@ -861,7 +867,47 @@ export default class LocalParticipant extends Participant {
     if (opts.source) {
       track.source = opts.source;
     }
-    const publishPromise = this.publish(track, opts, isStereo);
+    const publishPromise = new Promise<LocalTrackPublication>(async (resolve, reject) => {
+      try {
+        if (this.engine.client.currentState !== SignalConnectionState.CONNECTED) {
+          this.log.debug('deferring track publication until signal is connected', {
+            ...this.logContext,
+            track: getLogContextFromTrack(track),
+          });
+          const onSignalConnected = async () => {
+            try {
+              const publication = await this.publish(track, opts, isStereo);
+              resolve(publication);
+            } catch (e) {
+              reject(e);
+            }
+          };
+          setTimeout(() => {
+            this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
+            reject(
+              new PublishTrackError(
+                'publishing rejected as engine not connected within timeout',
+                408,
+              ),
+            );
+          }, 15_000);
+          this.engine.once(EngineEvent.SignalConnected, onSignalConnected);
+          this.engine.on(EngineEvent.Closing, () => {
+            this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
+            reject(new PublishTrackError('publishing rejected as engine closed', 499));
+          });
+        } else {
+          try {
+            const publication = await this.publish(track, opts, isStereo);
+            resolve(publication);
+          } catch (e) {
+            reject(e);
+          }
+        }
+      } catch (e) {
+        reject(e);
+      }
+    });
     this.pendingPublishPromises.set(track, publishPromise);
     try {
       const publication = await publishPromise;
@@ -963,7 +1009,7 @@ export default class LocalParticipant extends Participant {
       stereo: isStereo,
       disableRed: this.isE2EEEnabled || !(opts.red ?? true),
       stream: opts?.stream,
-      backupCodecPolicy: opts?.backupCodecPolicy,
+      backupCodecPolicy: opts?.backupCodecPolicy as BackupCodecPolicy,
     });
 
     // compute encodings and layers for video
@@ -1712,23 +1758,62 @@ export default class LocalParticipant extends Participant {
       onProgress?: (progress: number) => void;
     },
   ) {
-    const totalLength = file.size;
-    const header = new DataStream_Header({
-      totalLength: numberToBigInt(totalLength),
-      mimeType: options?.mimeType ?? file.type,
+    const writer = await this.streamBytes({
       streamId,
+      totalSize: file.size,
+      name: file.name,
+      mimeType: options?.mimeType ?? file.type,
       topic: options?.topic,
-      encryptionType: options?.encryptionType,
+      destinationIdentities: options?.destinationIdentities,
+    });
+    const reader = file.stream().getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      await writer.write(value);
+    }
+    await writer.close();
+    return writer.info;
+  }
+
+  async streamBytes(options?: {
+    name?: string;
+    topic?: string;
+    attributes?: Record<string, string>;
+    destinationIdentities?: Array<string>;
+    streamId?: string;
+    mimeType?: string;
+    totalSize?: number;
+  }) {
+    const streamId = options?.streamId ?? crypto.randomUUID();
+    const destinationIdentities = options?.destinationIdentities;
+
+    const info: ByteStreamInfo = {
+      id: streamId,
+      mimeType: options?.mimeType ?? 'application/octet-stream',
+      topic: options?.topic ?? '',
+      timestamp: Date.now(),
+      attributes: options?.attributes,
+      size: options?.totalSize,
+      name: options?.name ?? 'unknown',
+    };
+
+    const header = new DataStream_Header({
+      totalLength: numberToBigInt(info.size ?? 0),
+      mimeType: info.mimeType,
+      streamId,
+      topic: info.topic,
       timestamp: numberToBigInt(Date.now()),
       contentHeader: {
         case: 'byteHeader',
         value: new DataStream_ByteHeader({
-          name: file.name,
+          name: info.name,
         }),
       },
     });
 
-    const destinationIdentities = options?.destinationIdentities;
     const packet = new DataPacket({
       destinationIdentities,
       value: {
@@ -1738,47 +1823,61 @@ export default class LocalParticipant extends Participant {
     });
 
     await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
-    function read(b: Blob): Promise<Uint8Array> {
-      return new Promise((resolve) => {
-        const fr = new FileReader();
-        fr.onload = () => {
-          resolve(new Uint8Array(fr.result as ArrayBuffer));
-        };
-        fr.readAsArrayBuffer(b);
-      });
-    }
-    const totalChunks = Math.ceil(totalLength / STREAM_CHUNK_SIZE);
-    for (let i = 0; i < totalChunks; i++) {
-      const chunkData = await read(
-        file.slice(i * STREAM_CHUNK_SIZE, Math.min((i + 1) * STREAM_CHUNK_SIZE, totalLength)),
-      );
-      await this.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
-      const chunk = new DataStream_Chunk({
-        content: chunkData,
-        streamId,
-        chunkIndex: numberToBigInt(i),
-      });
-      const chunkPacket = new DataPacket({
-        destinationIdentities,
-        value: {
-          case: 'streamChunk',
-          value: chunk,
-        },
-      });
-      await this.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
-      options?.onProgress?.((i + 1) / totalChunks);
-    }
-    const trailer = new DataStream_Trailer({
-      streamId,
-    });
-    const trailerPacket = new DataPacket({
-      destinationIdentities,
-      value: {
-        case: 'streamTrailer',
-        value: trailer,
+
+    let chunkId = 0;
+    const writeMutex = new Mutex();
+    const engine = this.engine;
+    const log = this.log;
+
+    const writableStream = new WritableStream<Uint8Array>({
+      async write(chunk) {
+        const unlock = await writeMutex.lock();
+
+        let byteOffset = 0;
+        try {
+          while (byteOffset < chunk.byteLength) {
+            const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
+            await engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+            const chunkPacket = new DataPacket({
+              destinationIdentities,
+              value: {
+                case: 'streamChunk',
+                value: new DataStream_Chunk({
+                  content: subChunk,
+                  streamId,
+                  chunkIndex: numberToBigInt(chunkId),
+                }),
+              },
+            });
+            await engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+            chunkId += 1;
+            byteOffset += subChunk.byteLength;
+          }
+        } finally {
+          unlock();
+        }
+      },
+      async close() {
+        const trailer = new DataStream_Trailer({
+          streamId,
+        });
+        const trailerPacket = new DataPacket({
+          destinationIdentities,
+          value: {
+            case: 'streamTrailer',
+            value: trailer,
+          },
+        });
+        await engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+      },
+      abort(err) {
+        log.error('Sink error:', err);
       },
     });
-    await this.engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+
+    const byteWriter = new ByteStreamWriter(writableStream, info);
+
+    return byteWriter;
   }
 
   /**

package/src/room/track/LocalTrack.ts

@@ -314,7 +314,7 @@ export default abstract class LocalTrack<
       if (!constraints) {
         constraints = this._constraints;
       }
-      const { deviceId, ...otherConstraints } = constraints;
+      const { deviceId, facingMode, ...otherConstraints } = constraints;
       this.log.debug('restarting track with constraints', { ...this.logContext, constraints });
 
       const streamConstraints: MediaStreamConstraints = {
@@ -323,7 +323,7 @@ export default abstract class LocalTrack<
       };
 
       if (this.kind === Track.Kind.Video) {
-        streamConstraints.video = deviceId ? { deviceId } : true;
+        streamConstraints.video = deviceId || facingMode ? { deviceId, facingMode } : true;
       } else {
         streamConstraints.audio = deviceId ? { deviceId } : true;
       }

package/src/room/track/LocalVideoTrack.ts

@@ -7,11 +7,12 @@ import {
 } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
 import type { StructuredLogger } from '../../logger';
+import { getBrowser } from '../../utils/browserParser';
 import { ScalabilityMode } from '../participant/publishUtils';
 import type { VideoSenderStats } from '../stats';
 import { computeBitrate, monitorFrequency } from '../stats';
 import type { LoggerOptions } from '../types';
-import { isFireFox, isMobile, isWeb } from '../utils';
+import { compareVersions, isFireFox, isMobile, isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track, VideoQuality } from './Track';
 import type { VideoCaptureOptions, VideoCodec } from './options';
@@ -455,18 +456,15 @@ async function setPublishingLayersForSender(
     }
 
     let hasChanged = false;
-
-    /* disable closable spatial layer as it has video blur / frozen issue with current server / client
-    1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
-          low resolution frame and recover very quickly, but noticable
-    2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable */
-    const closableSpatial = false;
+    const browser = getBrowser();
+    const closableSpatial =
+      browser?.name === 'Chrome' && compareVersions(browser?.version, '133') > 0;
     /* @ts-ignore */
     if (closableSpatial && encodings[0].scalabilityMode) {
       // svc dynacast encodings
       const encoding = encodings[0];
       /* @ts-ignore */
-      // const mode = new ScalabilityMode(encoding.scalabilityMode);
+      const mode = new ScalabilityMode(encoding.scalabilityMode);
       let maxQuality = ProtoVideoQuality.OFF;
       qualities.forEach((q) => {
         if (q.enabled && (maxQuality === ProtoVideoQuality.OFF || q.quality > maxQuality)) {
@@ -479,22 +477,25 @@ async function setPublishingLayersForSender(
           encoding.active = false;
           hasChanged = true;
         }
-      } else if (!encoding.active /* || mode.spatial !== maxQuality + 1*/) {
+      } else if (!encoding.active || mode.spatial !== maxQuality + 1) {
         hasChanged = true;
         encoding.active = true;
-        /*
-        @ts-ignore
-        const originalMode = new ScalabilityMode(senderEncodings[0].scalabilityMode)
+        /* @ts-ignore */
+        const originalMode = new ScalabilityMode(senderEncodings[0].scalabilityMode);
         mode.spatial = maxQuality + 1;
         mode.suffix = originalMode.suffix;
         if (mode.spatial === 1) {
           // no suffix for L1Tx
           mode.suffix = undefined;
         }
-        @ts-ignore
+        /* @ts-ignore */
         encoding.scalabilityMode = mode.toString();
         encoding.scaleResolutionDownBy = 2 ** (2 - maxQuality);
-      */
+        if (senderEncodings[0].maxBitrate) {
+          encoding.maxBitrate =
+            senderEncodings[0].maxBitrate /
+            (encoding.scaleResolutionDownBy * encoding.scaleResolutionDownBy);
+        }
       }
     } else {
       // simulcast dynacast encodings