livekit-client 1.6.3 → 1.6.5

package/src/room/Room.ts

@@ -355,12 +355,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       } catch (err) {
         this.recreateEngine();
         this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
-        let errorMessage = '';
+        const resultingError = new ConnectionError(`could not establish signal connection`);
         if (err instanceof Error) {
-          errorMessage = err.message;
-          log.debug(`error trying to establish signal connection`, { error: err });
+          resultingError.message = `${resultingError.message}: ${err.message}`;
         }
-        reject(new ConnectionError(`could not establish signal connection: ${errorMessage}`));
+        if (err instanceof ConnectionError) {
+          resultingError.reason = err.reason;
+          resultingError.status = err.status;
+        }
+        log.debug(`error trying to establish signal connection`, { error: err });
+        reject(resultingError);
         return;
       }
 
@@ -843,10 +847,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
     // handle changes to participant state, and send events
     participantInfos.forEach((info) => {
-      if (
-        info.sid === this.localParticipant.sid ||
-        info.identity === this.localParticipant.identity
-      ) {
+      if (info.identity === this.localParticipant.identity) {
         this.localParticipant.updateInfo(info);
         return;
       }
@@ -1138,7 +1139,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       })
       .on(
         ParticipantEvent.ParticipantPermissionsChanged,
-        (prevPermissions: ParticipantPermission) => {
+        (prevPermissions?: ParticipantPermission) => {
           this.emitWhenConnected(
             RoomEvent.ParticipantPermissionsChanged,
             prevPermissions,
@@ -1273,7 +1274,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.MediaDevicesError, e);
   };
 
-  private onLocalParticipantPermissionsChanged = (prevPermissions: ParticipantPermission) => {
+  private onLocalParticipantPermissionsChanged = (prevPermissions?: ParticipantPermission) => {
     this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
   };
 
@@ -1442,7 +1443,7 @@ export type RoomEventCallbacks = {
     participant: RemoteParticipant | LocalParticipant,
   ) => void;
   participantPermissionsChanged: (
-    prevPermissions: ParticipantPermission,
+    prevPermissions: ParticipantPermission | undefined,
     participant: RemoteParticipant | LocalParticipant,
   ) => void;
   activeSpeakersChanged: (speakers: Array<Participant>) => void;

package/src/room/errors.ts

@@ -25,6 +25,12 @@ export class ConnectionError extends LivekitError {
   }
 }
 
+export class DeviceUnsupportedError extends LivekitError {
+  constructor(message?: string) {
+    super(21, message ?? 'device is unsupported');
+  }
+}
+
 export class TrackInvalidError extends LivekitError {
   constructor(message?: string) {
     super(20, message ?? 'track is invalid');

package/src/room/participant/LocalParticipant.ts

@@ -1,12 +1,7 @@
 import 'webrtc-adapter';
 import log from '../../logger';
 import type { InternalRoomOptions } from '../../options';
-import {
-  DataPacket,
-  DataPacket_Kind,
-  ParticipantInfo,
-  ParticipantPermission,
-} from '../../proto/livekit_models';
+import { DataPacket, DataPacket_Kind, ParticipantInfo } from '../../proto/livekit_models';
 import {
   AddTrackRequest,
   DataChannelInfo,
@@ -15,7 +10,7 @@ import {
   TrackPublishedResponse,
   TrackUnpublishedResponse,
 } from '../../proto/livekit_rtc';
-import { TrackInvalidError, UnexpectedConnectionState } from '../errors';
+import { DeviceUnsupportedError, TrackInvalidError, UnexpectedConnectionState } from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
 import type RTCEngine from '../RTCEngine';
 import LocalAudioTrack from '../track/LocalAudioTrack';
@@ -168,16 +163,6 @@ export default class LocalParticipant extends Participant {
     return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options, publishOptions);
   }
 
-  /** @internal */
-  setPermissions(permissions: ParticipantPermission): boolean {
-    const prevPermissions = this.permissions;
-    const changed = super.setPermissions(permissions);
-    if (changed && prevPermissions) {
-      this.emit(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions);
-    }
-    return changed;
-  }
-
   /**
    * Enable or disable publishing for a track by source. This serves as a simple
    * way to manage the common tracks (camera, mic, or screen share).
@@ -389,6 +374,11 @@ export default class LocalParticipant extends Participant {
         };
       }
     }
+
+    if (navigator.mediaDevices.getDisplayMedia === undefined) {
+      throw new DeviceUnsupportedError('getDisplayMedia not supported');
+    }
+
     const stream: MediaStream = await navigator.mediaDevices.getDisplayMedia({
       audio: options.audio ?? false,
       video: videoConstraints,
@@ -876,6 +866,11 @@ export default class LocalParticipant extends Participant {
 
   /** @internal */
   updateInfo(info: ParticipantInfo) {
+    if (info.sid !== this.sid) {
+      // drop updates that specify a wrong sid.
+      // the sid for local participant is only explicitly set on join and full reconnect
+      return;
+    }
     super.updateInfo(info);
 
     // reconcile track mute status.
@@ -1004,7 +999,9 @@ export default class LocalParticipant extends Participant {
               // detect granted change after permissions were denied to try and resume then
               currentPermissions.onchange = () => {
                 if (currentPermissions.state !== 'denied') {
-                  track.restartTrack();
+                  if (!track.isMuted) {
+                    track.restartTrack();
+                  }
                   currentPermissions.onchange = null;
                 }
               };
@@ -1014,8 +1011,10 @@ export default class LocalParticipant extends Participant {
             // permissions query fails for firefox, we continue and try to restart the track
           }
         }
-        log.debug('track ended, attempting to use a different device');
-        await track.restartTrack();
+        if (!track.isMuted) {
+          log.debug('track ended, attempting to use a different device');
+          await track.restartTrack();
+        }
       } catch (e) {
         log.warn(`could not restart track, muting instead`);
         await track.mute();

package/src/room/participant/Participant.ts

@@ -173,14 +173,22 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
 
   /** @internal */
   setPermissions(permissions: ParticipantPermission): boolean {
+    const prevPermissions = this.permissions;
     const changed =
       permissions.canPublish !== this.permissions?.canPublish ||
       permissions.canSubscribe !== this.permissions?.canSubscribe ||
       permissions.canPublishData !== this.permissions?.canPublishData ||
       permissions.hidden !== this.permissions?.hidden ||
-      permissions.recorder !== this.permissions?.recorder;
+      permissions.recorder !== this.permissions?.recorder ||
+      permissions.canPublishSources.length !== this.permissions.canPublishSources.length ||
+      permissions.canPublishSources.some(
+        (value, index) => value !== this.permissions?.canPublishSources[index],
+      );
     this.permissions = permissions;
 
+    if (changed) {
+      this.emit(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions);
+    }
     return changed;
   }
 
@@ -257,7 +265,7 @@ export type ParticipantEventCallbacks = {
     status: TrackPublication.PermissionStatus,
   ) => void;
   mediaDevicesError: (error: Error) => void;
-  participantPermissionsChanged: (prevPermissions: ParticipantPermission) => void;
+  participantPermissionsChanged: (prevPermissions?: ParticipantPermission) => void;
   trackSubscriptionStatusChanged: (
     publication: RemoteTrackPublication,
     status: TrackPublication.SubscriptionStatus,

package/src/room/track/LocalAudioTrack.ts

@@ -53,7 +53,11 @@ export default class LocalAudioTrack extends LocalTrack {
 
   async unmute(): Promise<LocalAudioTrack> {
     await this.muteQueue.run(async () => {
-      if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+      if (
+        this.source === Track.Source.Microphone &&
+        (this.stopOnMute || this._mediaStreamTrack.readyState === 'ended') &&
+        !this.isUserProvided
+      ) {
         log.debug('reacquiring mic track');
         await this.restartTrack();
       }

package/src/room/track/create.ts

@@ -1,5 +1,5 @@
 import DeviceManager from '../DeviceManager';
-import { TrackInvalidError } from '../errors';
+import { DeviceUnsupportedError, TrackInvalidError } from '../errors';
 import { mediaTrackToLocalTrack } from '../participant/publishUtils';
 import { audioDefaults, videoDefaults } from '../defaults';
 import LocalAudioTrack from './LocalAudioTrack';
@@ -114,6 +114,11 @@ export async function createLocalScreenTracks(
       height: options.resolution.height,
     };
   }
+
+  if (navigator.mediaDevices.getDisplayMedia === undefined) {
+    throw new DeviceUnsupportedError('getDisplayMedia not supported');
+  }
+
   // typescript definition is missing getDisplayMedia: https://github.com/microsoft/TypeScript/issues/33232
   // @ts-ignore
   const stream: MediaStream = await navigator.mediaDevices.getDisplayMedia({

package/src/room/track/options.ts

@@ -232,9 +232,9 @@ export interface AudioPreset {
 const codecs = ['vp8', 'h264', 'av1'] as const;
 const backupCodecs = ['vp8', 'h264'] as const;
 
-export type VideoCodec = typeof codecs[number];
+export type VideoCodec = (typeof codecs)[number];
 
-export type BackupVideoCodec = typeof backupCodecs[number];
+export type BackupVideoCodec = (typeof backupCodecs)[number];
 
 export function isBackupCodec(codec: string): codec is BackupVideoCodec {
   return !!backupCodecs.find((backup) => backup === codec);