livekit-client 1.6.7 → 1.6.8

package/src/room/RTCEngine.ts

@@ -341,8 +341,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           this.handleDisconnect(
             'primary peerconnection',
             subscriberPrimary
-              ? ReconnectReason.REASON_SUBSCRIBER_FAILED
-              : ReconnectReason.REASON_PUBLISHER_FAILED,
+              ? ReconnectReason.RR_SUBSCRIBER_FAILED
+              : ReconnectReason.RR_PUBLISHER_FAILED,
           );
         }
       }
@@ -354,8 +354,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.handleDisconnect(
           'secondary peerconnection',
           subscriberPrimary
-            ? ReconnectReason.REASON_PUBLISHER_FAILED
-            : ReconnectReason.REASON_SUBSCRIBER_FAILED,
+            ? ReconnectReason.RR_PUBLISHER_FAILED
+            : ReconnectReason.RR_SUBSCRIBER_FAILED,
         );
       }
     };
@@ -423,7 +423,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     };
 
     this.client.onClose = () => {
-      this.handleDisconnect('signal', ReconnectReason.REASON_SIGNAL_DISCONNECTED);
+      this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
     };
 
     this.client.onLeave = (leave?: LeaveRequest) => {
@@ -775,7 +775,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
 
       if (recoverable) {
-        this.handleDisconnect('reconnect', ReconnectReason.REASON_UNKOWN);
+        this.handleDisconnect('reconnect', ReconnectReason.RR_UNKOWN);
       } else {
         log.info(
           `could not recover connection after ${this.reconnectAttempts} attempts, ${
@@ -1011,7 +1011,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
       const negotiationTimeout = setTimeout(() => {
         reject('negotiation timed out');
-        this.handleDisconnect('negotiation', ReconnectReason.REASON_SIGNAL_DISCONNECTED);
+        this.handleDisconnect('negotiation', ReconnectReason.RR_SIGNAL_DISCONNECTED);
       }, this.peerConnectionTimeout);
 
       const cleanup = () => {
@@ -1032,7 +1032,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         if (e instanceof NegotiationError) {
           this.fullReconnectOnNext = true;
         }
-        this.handleDisconnect('negotiation', ReconnectReason.REASON_UNKOWN);
+        this.handleDisconnect('negotiation', ReconnectReason.RR_UNKOWN);
       });
     });
   }
@@ -1076,7 +1076,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     // in case the engine is currently reconnecting, attempt a reconnect immediately after the browser state has changed to 'onLine'
     if (this.client.isReconnecting) {
       this.clearReconnectTimeout();
-      this.attemptReconnect(ReconnectReason.REASON_SIGNAL_DISCONNECTED);
+      this.attemptReconnect(ReconnectReason.RR_SIGNAL_DISCONNECTED);
     }
   };
 

package/src/room/Room.ts

@@ -758,48 +758,53 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     log.debug(`reconnected to server`, {
       region: joinResponse.serverRegion,
     });
-    this.setAndEmitConnectionState(ConnectionState.Connected);
-    this.emit(RoomEvent.Reconnected);
-
-    // rehydrate participants
-    if (joinResponse.participant) {
-      // with a restart, the sid will have changed, we'll map our understanding to it
-      this.localParticipant.sid = joinResponse.participant.sid;
-      this.handleParticipantUpdates([joinResponse.participant]);
-    }
-    this.handleParticipantUpdates(joinResponse.otherParticipants);
 
-    // unpublish & republish tracks
-    const localPubs: LocalTrackPublication[] = [];
-    this.localParticipant.tracks.forEach((pub) => {
-      if (pub.track) {
-        localPubs.push(pub);
+    try {
+      // rehydrate participants
+      if (joinResponse.participant) {
+        // with a restart, the sid will have changed, we'll map our understanding to it
+        this.localParticipant.sid = joinResponse.participant.sid;
+        this.handleParticipantUpdates([joinResponse.participant]);
       }
-    });
+      this.handleParticipantUpdates(joinResponse.otherParticipants);
 
-    await Promise.all(
-      localPubs.map(async (pub) => {
-        const track = pub.track!;
-        this.localParticipant.unpublishTrack(track, false);
-        if (!track.isMuted) {
-          if (
-            (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) &&
-            !track.isUserProvided
-          ) {
-            // we need to restart the track before publishing, often a full reconnect
-            // is necessary because computer had gone to sleep.
-            log.debug('restarting existing track', {
+      // unpublish & republish tracks
+      const localPubs: LocalTrackPublication[] = [];
+      this.localParticipant.tracks.forEach((pub) => {
+        if (pub.track) {
+          localPubs.push(pub);
+        }
+      });
+
+      await Promise.all(
+        localPubs.map(async (pub) => {
+          const track = pub.track!;
+          this.localParticipant.unpublishTrack(track, false);
+          if (!track.isMuted) {
+            if (
+              (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) &&
+              !track.isUserProvided
+            ) {
+              // we need to restart the track before publishing, often a full reconnect
+              // is necessary because computer had gone to sleep.
+              log.debug('restarting existing track', {
+                track: pub.trackSid,
+              });
+              await track.restartTrack();
+            }
+            log.debug('publishing new track', {
               track: pub.trackSid,
             });
-            await track.restartTrack();
+            await this.localParticipant.publishTrack(track, pub.options);
           }
-          log.debug('publishing new track', {
-            track: pub.trackSid,
-          });
-          await this.localParticipant.publishTrack(track, pub.options);
-        }
-      }),
-    );
+        }),
+      );
+    } catch (error) {
+      log.error('error trying to re-publish tracks after reconnection', { error });
+    } finally {
+      this.setAndEmitConnectionState(ConnectionState.Connected);
+      this.emit(RoomEvent.Reconnected);
+    }
   };
 
   private handleDisconnect(shouldStopTracks = true, reason?: DisconnectReason) {
@@ -872,15 +877,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       let remoteParticipant = this.participants.get(info.sid);
       const isNewParticipant = !remoteParticipant;
 
-      // create participant if doesn't exist
-      remoteParticipant = this.getOrCreateParticipant(info.sid, info);
-
       // when it's disconnected, send updates
       if (info.state === ParticipantInfo_State.DISCONNECTED) {
         this.handleParticipantDisconnected(info.sid, remoteParticipant);
-      } else if (!isNewParticipant) {
-        // just update, no events
-        remoteParticipant.updateInfo(info);
+      } else {
+        // create participant if doesn't exist
+        remoteParticipant = this.getOrCreateParticipant(info.sid, info);
+        if (!isNewParticipant) {
+          // just update, no events
+          remoteParticipant.updateInfo(info);
+        }
       }
     });
   };
@@ -1001,7 +1007,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // find the participant
     const participant = this.participants.get(userPacket.participantSid);
 
-    this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind);
+    this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind, userPacket.topic);
 
     // also emit on the participant
     participant?.emit(ParticipantEvent.DataReceived, userPacket.payload, kind);
@@ -1462,6 +1468,7 @@ export type RoomEventCallbacks = {
     payload: Uint8Array,
     participant?: RemoteParticipant,
     kind?: DataPacket_Kind,
+    topic?: string,
   ) => void;
   connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void;
   mediaDevicesError: (error: Error) => void;

package/src/room/events.ts

@@ -175,7 +175,7 @@ export enum RoomEvent {
    * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
    * All participants in the room will receive the messages sent to the room.
    *
-   * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]])
+   * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]], topic?: string)
    */
   DataReceived = 'dataReceived',
 

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() &&
@@ -452,22 +496,27 @@ export default class LocalParticipant extends Participant {
       ...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,
     );
@@ -806,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
@@ -821,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);
         }
       });
     }
@@ -840,7 +917,8 @@ export default class LocalParticipant extends Participant {
         user: {
           participantSid: this.sid,
           payload: data,
-          destinationSids: dest,
+          destinationSids: destinationSids,
+          topic,
         },
       },
     };

package/src/room/track/options.ts

@@ -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;