livekit-client 1.6.6 → 1.6.8

package/src/room/participant/LocalParticipant.ts

@@ -29,7 +29,8 @@ import {
 } from '../track/options';
 import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
-import { isFireFox, isSafari, isWeb, supportsAV1 } from '../utils';
+import type { DataPublishOptions } from '../types';
+import { Future, isFireFox, isSafari, isWeb, supportsAV1 } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
 import {
@@ -52,6 +53,8 @@ export default class LocalParticipant extends Participant {
 
   private pendingPublishing = new Set<Track.Source>();
 
+  private pendingPublishPromises = new Map<LocalTrack, Promise<LocalTrackPublication>>();
+
   private cameraError: Error | undefined;
 
   private microphoneError: Error | undefined;
@@ -63,6 +66,8 @@ export default class LocalParticipant extends Participant {
   // keep a pointer to room options
   private roomOptions: InternalRoomOptions;
 
+  private reconnectFuture?: Future<void>;
+
   /** @internal */
   constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions) {
     super(sid, identity);
@@ -118,11 +123,25 @@ export default class LocalParticipant extends Participant {
     this.engine.client.onLocalTrackUnpublished = this.handleLocalTrackUnpublished;
 
     this.engine
-      .on(EngineEvent.Connected, this.updateTrackSubscriptionPermissions)
-      .on(EngineEvent.Restarted, this.updateTrackSubscriptionPermissions)
-      .on(EngineEvent.Resumed, this.updateTrackSubscriptionPermissions);
+      .on(EngineEvent.Connected, this.handleReconnected)
+      .on(EngineEvent.Restarted, this.handleReconnected)
+      .on(EngineEvent.Resumed, this.handleReconnected)
+      .on(EngineEvent.Restarting, this.handleReconnecting)
+      .on(EngineEvent.Resuming, this.handleReconnecting);
   }
 
+  private handleReconnecting = () => {
+    if (!this.reconnectFuture) {
+      this.reconnectFuture = new Future<void>();
+    }
+  };
+
+  private handleReconnected = () => {
+    this.reconnectFuture?.resolve?.();
+    this.reconnectFuture = undefined;
+    this.updateTrackSubscriptionPermissions();
+  };
+
   /**
    * Enable or disable a participant's camera track.
    *
@@ -382,6 +401,11 @@ export default class LocalParticipant extends Participant {
     const stream: MediaStream = await navigator.mediaDevices.getDisplayMedia({
       audio: options.audio ?? false,
       video: videoConstraints,
+      // @ts-expect-error support for experimental display media features
+      controller: options.controller,
+      selfBrowserSurface: options.selfBrowserSurface,
+      surfaceSwitching: options.surfaceSwitching,
+      systemAudio: options.systemAudio,
     });
 
     const tracks = stream.getVideoTracks();
@@ -408,6 +432,10 @@ export default class LocalParticipant extends Participant {
     track: LocalTrack | MediaStreamTrack,
     options?: TrackPublishOptions,
   ): Promise<LocalTrackPublication> {
+    await this.reconnectFuture?.promise;
+    if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
+      await this.pendingPublishPromises.get(track);
+    }
     // convert raw media track into audio or video track
     if (track instanceof MediaStreamTrack) {
       switch (track.kind) {
@@ -422,6 +450,22 @@ export default class LocalParticipant extends Participant {
       }
     }
 
+    // is it already published? if so skip
+    let existingPublication: LocalTrackPublication | undefined;
+    this.tracks.forEach((publication) => {
+      if (!publication.track) {
+        return;
+      }
+      if (publication.track === track) {
+        existingPublication = <LocalTrackPublication>publication;
+      }
+    });
+
+    if (existingPublication) {
+      log.warn('track has already been published, skipping');
+      return existingPublication;
+    }
+
     const isStereo =
       options?.forceStereo ||
       ('channelCount' in track.mediaStreamTrack.getSettings() &&
@@ -439,29 +483,40 @@ export default class LocalParticipant extends Participant {
           `Opus DTX will be disabled for stereo tracks by default. Enable them explicitly to make it work.`,
         );
       }
+      if (options.red === undefined) {
+        log.info(
+          `Opus RED will be disabled for stereo tracks by default. Enable them explicitly to make it work.`,
+        );
+      }
       options.dtx ??= false;
+      options.red ??= false;
     }
     const opts: TrackPublishOptions = {
       ...this.roomOptions.publishDefaults,
       ...options,
     };
 
-    // is it already published? if so skip
-    let existingPublication: LocalTrackPublication | undefined;
-    this.tracks.forEach((publication) => {
-      if (!publication.track) {
-        return;
-      }
-      if (publication.track === track) {
-        existingPublication = <LocalTrackPublication>publication;
-      }
-    });
-
-    if (existingPublication) return existingPublication;
-
     if (opts.source) {
       track.source = opts.source;
     }
+    const publishPromise = this.publish(track, opts, options, isStereo);
+    this.pendingPublishPromises.set(track, publishPromise);
+    try {
+      const publication = await publishPromise;
+      return publication;
+    } catch (e) {
+      throw e;
+    } finally {
+      this.pendingPublishPromises.delete(track);
+    }
+  }
+
+  private async publish(
+    track: LocalTrack,
+    opts: TrackPublishOptions,
+    options: TrackPublishOptions | undefined,
+    isStereo: boolean,
+  ) {
     const existingTrackOfSource = Array.from(this.tracks.values()).find(
       (publishedTrack) => track instanceof LocalTrack && publishedTrack.source === track.source,
     );
@@ -721,17 +776,24 @@ export default class LocalParticipant extends Participant {
       track.stop();
     }
 
+    let negotiationNeeded = false;
+    const trackSender = track.sender;
+    track.sender = undefined;
     if (
       this.engine.publisher &&
       this.engine.publisher.pc.connectionState !== 'closed' &&
-      track.sender
+      trackSender
     ) {
       try {
-        this.engine.removeTrack(track.sender);
+        if (this.engine.removeTrack(trackSender)) {
+          negotiationNeeded = true;
+        }
         if (track instanceof LocalVideoTrack) {
           for (const [, trackInfo] of track.simulcastCodecs) {
             if (trackInfo.sender) {
-              this.engine.removeTrack(trackInfo.sender);
+              if (this.engine.removeTrack(trackInfo.sender)) {
+                negotiationNeeded = true;
+              }
               trackInfo.sender = undefined;
             }
           }
@@ -739,13 +801,9 @@ export default class LocalParticipant extends Participant {
         }
       } catch (e) {
         log.warn('failed to unpublish track', { error: e, method: 'unpublishTrack' });
-      } finally {
-        await this.engine.negotiate();
       }
     }
 
-    track.sender = undefined;
-
     // remove from our maps
     this.tracks.delete(publication.trackSid);
     switch (publication.kind) {
@@ -762,6 +820,9 @@ export default class LocalParticipant extends Participant {
     this.emit(ParticipantEvent.LocalTrackUnpublished, publication);
     publication.setTrack(undefined);
 
+    if (negotiationNeeded) {
+      await this.engine.negotiate();
+    }
     return publication;
   }
 
@@ -794,6 +855,22 @@ export default class LocalParticipant extends Participant {
     );
   }
 
+  /**
+   * Publish a new data payload to the room. Data will be forwarded to each
+   * participant in the room if the destination field in publishOptions is empty
+   *
+   * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
+   * @param kind whether to send this as reliable or lossy.
+   * For data that you need delivery guarantee (such as chat messages), use Reliable.
+   * For data that should arrive as quickly as possible, but you are ok with dropped
+   * packets, use Lossy.
+   * @param publishOptions optionally specify a `topic` and `destination`
+   */
+  async publishData(
+    data: Uint8Array,
+    kind: DataPacket_Kind,
+    publishOptions?: DataPublishOptions,
+  ): Promise<void>;
   /**
    * Publish a new data payload to the room. Data will be forwarded to each
    * participant in the room if the destination argument is empty
@@ -809,14 +886,26 @@ export default class LocalParticipant extends Participant {
     data: Uint8Array,
     kind: DataPacket_Kind,
     destination?: RemoteParticipant[] | string[],
+  ): Promise<void>;
+
+  async publishData(
+    data: Uint8Array,
+    kind: DataPacket_Kind,
+    publishOptions: DataPublishOptions | RemoteParticipant[] | string[] = {},
   ) {
-    const dest: string[] = [];
+    const destination = Array.isArray(publishOptions)
+      ? publishOptions
+      : publishOptions?.destination;
+    const destinationSids: string[] = [];
+
+    const topic = !Array.isArray(publishOptions) ? publishOptions.topic : undefined;
+
     if (destination !== undefined) {
       destination.forEach((val: any) => {
         if (val instanceof RemoteParticipant) {
-          dest.push(val.sid);
+          destinationSids.push(val.sid);
         } else {
-          dest.push(val);
+          destinationSids.push(val);
         }
       });
     }
@@ -828,7 +917,8 @@ export default class LocalParticipant extends Participant {
         user: {
           participantSid: this.sid,
           payload: data,
-          destinationSids: dest,
+          destinationSids: destinationSids,
+          topic,
         },
       },
     };

package/src/room/participant/RemoteParticipant.ts

@@ -236,8 +236,7 @@ export default class RemoteParticipant extends Participant {
         }
         publication = new RemoteTrackPublication(
           kind,
-          ti.sid,
-          ti.name,
+          ti,
           this.signalClient.connectOptions?.autoSubscribe,
         );
         publication.updateInfo(ti);
@@ -246,7 +245,7 @@ export default class RemoteParticipant extends Participant {
           (publishedTrack) => publishedTrack.source === publication?.source,
         );
         if (existingTrackOfSource && publication.source !== Track.Source.Unknown) {
-          log.warn(
+          log.debug(
             `received a second track publication for ${this.identity} with the same source: ${publication.source}`,
             {
               oldTrack: existingTrackOfSource,

package/src/room/track/RemoteTrackPublication.ts

@@ -24,9 +24,10 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   protected fps?: number;
 
-  constructor(kind: Track.Kind, id: string, name: string, autoSubscribe: boolean | undefined) {
-    super(kind, id, name);
+  constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined) {
+    super(kind, ti.sid, ti.name);
     this.subscribed = autoSubscribe;
+    this.updateInfo(ti);
   }
 
   /**

package/src/room/track/RemoteVideoTrack.ts

@@ -31,9 +31,6 @@ export default class RemoteVideoTrack extends RemoteTrack {
   ) {
     super(mediaTrack, sid, Track.Kind.Video, receiver);
     this.adaptiveStreamSettings = adaptiveStreamSettings;
-    if (this.isAdaptiveStream) {
-      this.streamState = Track.StreamState.Paused;
-    }
   }
 
   get isAdaptiveStream(): boolean {

package/src/room/track/Track.ts

@@ -32,7 +32,8 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
   mediaStream?: MediaStream;
 
   /**
-   * indicates current state of stream
+   * indicates current state of stream, it'll indicate `paused` if the track
+   * has been paused by congestion controller
    */
   streamState: Track.StreamState = Track.StreamState.Active;
 

package/src/room/track/options.ts

@@ -28,12 +28,12 @@ export interface TrackPublishDefaults {
   audioBitrate?: number;
 
   /**
-   * dtx (Discontinuous Transmission of audio), defaults to true
+   * dtx (Discontinuous Transmission of audio), enabled by default for mono tracks.
    */
   dtx?: boolean;
 
   /**
-   * red (Redundant Audio Data), defaults to true
+   * red (Redundant Audio Data), enabled by default for mono tracks.
    */
   red?: boolean;
 
@@ -133,6 +133,18 @@ export interface ScreenShareCaptureOptions {
 
   /** capture resolution, defaults to full HD */
   resolution?: VideoResolution;
+
+  /** a CaptureController object instance containing methods that can be used to further manipulate the capture session if included. */
+  controller?: unknown; // TODO replace type with CaptureController once it lands in TypeScript
+
+  /** specifies whether the browser should allow the user to select the current tab for capture */
+  selfBrowserSurface?: 'include' | 'exclude';
+
+  /** specifies whether the browser should display a control to allow the user to dynamically switch the shared tab during screen-sharing. */
+  surfaceSwitching?: 'include' | 'exclude';
+
+  /** specifies whether the browser should include the system audio among the possible audio sources offered to the user */
+  systemAudio?: 'include' | 'exclude';
 }
 
 export interface AudioCaptureOptions {

package/src/room/types.ts

@@ -1,3 +1,5 @@
+import type RemoteParticipant from './participant/RemoteParticipant';
+
 export type SimulationOptions = {
   publish?: {
     audio?: boolean;
@@ -11,3 +13,10 @@ export type SimulationOptions = {
     video?: boolean;
   };
 };
+
+export type DataPublishOptions = {
+  /** the participants who will receive the message, will be sent to every one if empty */
+  destination?: RemoteParticipant[] | string[];
+  /** the topic under which the message gets published */
+  topic?: string;
+};

package/src/version.ts

@@ -1,4 +1,4 @@
 import { version as v } from '../package.json';
 
 export const version = v;
-export const protocolVersion = 8;
+export const protocolVersion = 9;