livekit-client 1.1.7 → 1.2.0

package/src/room/events.ts

@@ -402,6 +402,8 @@ export enum TrackEvent {
   Muted = 'muted',
   Unmuted = 'unmuted',
   Ended = 'ended',
+  Subscribed = 'subscribed',
+  Unsubscribed = 'unsubscribed',
   /** @internal */
   UpdateSettings = 'updateSettings',
   /** @internal */
@@ -433,4 +435,9 @@ export enum TrackEvent {
    * Only fires on LocalTracks
    */
   UpstreamResumed = 'upstreamResumed',
+  /**
+   * @internal
+   * Fires on RemoteTrackPublication
+   */
+  SubscriptionPermissionChanged = 'subscriptionPermissionChanged',
 }

package/src/room/participant/LocalParticipant.ts

@@ -32,7 +32,7 @@ import {
 } from '../track/options';
 import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
-import { isFireFox } from '../utils';
+import { isFireFox, isWeb } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
 import { computeVideoEncodings, mediaTrackToLocalTrack } from './publishUtils';
@@ -894,11 +894,49 @@ export default class LocalParticipant extends Participant {
     this.unpublishTrack(track.track!);
   };
 
-  private handleTrackEnded = (track: LocalTrack) => {
-    log.debug('unpublishing local track due to TrackEnded', {
-      track: track.sid,
-    });
-    this.unpublishTrack(track);
+  private handleTrackEnded = async (track: LocalTrack) => {
+    if (
+      track.source === Track.Source.ScreenShare ||
+      track.source === Track.Source.ScreenShareAudio
+    ) {
+      log.debug('unpublishing local track due to TrackEnded', {
+        track: track.sid,
+      });
+      this.unpublishTrack(track);
+    } else if (track.isUserProvided) {
+      await track.pauseUpstream();
+    } else if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
+      try {
+        if (isWeb()) {
+          try {
+            const currentPermissions = await navigator?.permissions.query({
+              // the permission query for camera and microphone currently not supported in Safari and Firefox
+              // @ts-ignore
+              name: track.source === Track.Source.Camera ? 'camera' : 'microphone',
+            });
+            if (currentPermissions && currentPermissions.state === 'denied') {
+              log.warn(`user has revoked access to ${track.source}`);
+
+              // detect granted change after permissions were denied to try and resume then
+              currentPermissions.onchange = () => {
+                if (currentPermissions.state !== 'denied') {
+                  track.restartTrack();
+                  currentPermissions.onchange = null;
+                }
+              };
+              throw new Error('GetUserMedia Permission denied');
+            }
+          } catch (e: any) {
+            // 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();
+      } catch (e) {
+        log.warn(`could not restart track, pausing upstream instead`);
+        await track.pauseUpstream();
+      }
+    }
   };
 
   private getPublicationForTrack(
@@ -975,7 +1013,7 @@ export default class LocalParticipant extends Participant {
     this.tracks.forEach((track: LocalTrackPublication) => {
       if (track.track !== undefined) {
         infos.push({
-          cid: track.track.mediaStreamTrack.id,
+          cid: track.track.mediaStreamID,
           track: track.trackInfo,
         });
       }

package/src/room/participant/Participant.ts

@@ -12,6 +12,7 @@ import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import { TrackPublication } from '../track/TrackPublication';
 import { RemoteTrack } from '../track/types';
+import log from '../../logger';
 
 export enum ConnectionQuality {
   Excellent = 'excellent',
@@ -179,6 +180,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     }
     // set this last so setMetadata can detect changes
     this.participantInfo = info;
+    log.trace('update participant info', { info });
   }
 
   /** @internal */

package/src/room/participant/RemoteParticipant.ts

@@ -7,6 +7,7 @@ import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import RemoteVideoTrack from '../track/RemoteVideoTrack';
 import { Track } from '../track/Track';
+import { TrackPublication } from '../track/TrackPublication';
 import { AdaptiveStreamSettings, RemoteTrack } from '../track/types';
 import Participant, { ParticipantEventCallbacks } from './Participant';
 
@@ -49,8 +50,17 @@ export default class RemoteParticipant extends Participant {
       });
       this.signalClient.sendUpdateSubscription(sub);
     });
-    publication.on(TrackEvent.Ended, (track: RemoteTrack) => {
-      this.emit(ParticipantEvent.TrackUnsubscribed, track, publication);
+    publication.on(
+      TrackEvent.SubscriptionPermissionChanged,
+      (status: TrackPublication.SubscriptionStatus) => {
+        this.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, publication, status);
+      },
+    );
+    publication.on(TrackEvent.Subscribed, (track: RemoteTrack) => {
+      this.emit(ParticipantEvent.TrackSubscribed, track, publication);
+    });
+    publication.on(TrackEvent.Unsubscribed, (previousTrack: RemoteTrack) => {
+      this.emit(ParticipantEvent.TrackUnsubscribed, previousTrack, publication);
     });
   }
 
@@ -156,8 +166,6 @@ export default class RemoteParticipant extends Participant {
     track.start();
 
     publication.setTrack(track);
-    // subscription means participant has permissions to subscribe
-    publication._allowed = true;
     // set participant volume on new microphone tracks
     if (
       this.volume !== undefined &&
@@ -166,7 +174,6 @@ export default class RemoteParticipant extends Participant {
     ) {
       track.setVolume(this.volume);
     }
-    this.emit(ParticipantEvent.TrackSubscribed, track, publication);
 
     return publication;
   }
@@ -218,6 +225,10 @@ export default class RemoteParticipant extends Participant {
     // detect removed tracks
     this.tracks.forEach((publication) => {
       if (!validTracks.has(publication.trackSid)) {
+        log.trace('detected removed track on remote participant, unpublishing', {
+          publication,
+          participantSid: this.sid,
+        });
         this.unpublishTrack(publication.trackSid, true);
       }
     });
@@ -247,13 +258,8 @@ export default class RemoteParticipant extends Participant {
     // also send unsubscribe, if track is actively subscribed
     const { track } = publication;
     if (track) {
-      const { isSubscribed } = publication;
       track.stop();
       publication.setTrack(undefined);
-      // always send unsubscribed, since apps may rely on this
-      if (isSubscribed) {
-        this.emit(ParticipantEvent.TrackUnsubscribed, track, publication);
-      }
     }
     if (sendUnpublish) {
       this.emit(ParticipantEvent.TrackUnpublished, publication);

package/src/room/track/LocalAudioTrack.ts

@@ -35,22 +35,26 @@ export default class LocalAudioTrack extends LocalTrack {
   }
 
   async mute(): Promise<LocalAudioTrack> {
-    // disabled special handling as it will cause BT headsets to switch communication modes
-    if (this.source === Track.Source.Microphone && this.stopOnMute) {
-      log.debug('stopping mic track');
-      // also stop the track, so that microphone indicator is turned off
-      this._mediaStreamTrack.stop();
-    }
-    await super.mute();
+    await this.muteQueue.run(async () => {
+      // disabled special handling as it will cause BT headsets to switch communication modes
+      if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+        log.debug('stopping mic track');
+        // also stop the track, so that microphone indicator is turned off
+        this._mediaStreamTrack.stop();
+      }
+      await super.mute();
+    });
     return this;
   }
 
   async unmute(): Promise<LocalAudioTrack> {
-    if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
-      log.debug('reacquiring mic track');
-      await this.restartTrack();
-    }
-    await super.unmute();
+    await this.muteQueue.run(async () => {
+      if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+        log.debug('reacquiring mic track');
+        await this.restartTrack();
+      }
+      await super.unmute();
+    });
     return this;
   }
 

package/src/room/track/LocalTrack.ts

@@ -1,9 +1,10 @@
+import Queue from 'async-await-queue';
 import log from '../../logger';
 import DeviceManager from '../DeviceManager';
 import { TrackInvalidError } from '../errors';
 import { TrackEvent } from '../events';
-import { VideoCodec } from './options';
 import { getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isMobile } from '../utils';
+import { VideoCodec } from './options';
 import { attachToElement, detachTrack, Track } from './Track';
 
 export default class LocalTrack extends Track {
@@ -21,6 +22,8 @@ export default class LocalTrack extends Track {
 
   protected providedByUser: boolean;
 
+  protected muteQueue: Queue;
+
   protected constructor(
     mediaTrack: MediaStreamTrack,
     kind: Track.Kind,
@@ -33,6 +36,7 @@ export default class LocalTrack extends Track {
     this.reacquireTrack = false;
     this.wasMuted = false;
     this.providedByUser = userProvidedTrack;
+    this.muteQueue = new Queue();
   }
 
   get id(): string {
@@ -101,7 +105,9 @@ export default class LocalTrack extends Track {
     // on Safari, the old audio track must be stopped before attempting to acquire
     // the new track, otherwise the new track will stop with
     // 'A MediaStreamTrack ended due to a capture failure`
-    this._mediaStreamTrack.stop();
+    if (!this.providedByUser) {
+      this._mediaStreamTrack.stop();
+    }
 
     track.addEventListener('ended', this.handleEnded);
     log.debug('replace MediaStreamTrack');
@@ -111,6 +117,8 @@ export default class LocalTrack extends Track {
     }
     this._mediaStreamTrack = track;
 
+    await this.resumeUpstream();
+
     this.attachedElements.forEach((el) => {
       attachToElement(track, el);
     });
@@ -160,6 +168,8 @@ export default class LocalTrack extends Track {
 
     this._mediaStreamTrack = newTrack;
 
+    await this.resumeUpstream();
+
     this.attachedElements.forEach((el) => {
       attachToElement(newTrack, el);
     });
@@ -170,6 +180,7 @@ export default class LocalTrack extends Track {
   }
 
   protected setTrackMuted(muted: boolean) {
+    log.debug(`setting ${this.kind} track ${muted ? 'muted' : 'unmuted'}`);
     if (this.isMuted === muted) {
       return;
     }
@@ -215,31 +226,36 @@ export default class LocalTrack extends Track {
   };
 
   async pauseUpstream() {
-    if (this._isUpstreamPaused === true) {
-      return;
-    }
-    if (!this.sender) {
-      log.warn('unable to pause upstream for an unpublished track');
-      return;
-    }
-    this._isUpstreamPaused = true;
-    this.emit(TrackEvent.UpstreamPaused, this);
-    const emptyTrack =
-      this.kind === Track.Kind.Audio ? getEmptyAudioStreamTrack() : getEmptyVideoStreamTrack();
-    await this.sender.replaceTrack(emptyTrack);
+    this.muteQueue.run(async () => {
+      if (this._isUpstreamPaused === true) {
+        return;
+      }
+      if (!this.sender) {
+        log.warn('unable to pause upstream for an unpublished track');
+        return;
+      }
+
+      this._isUpstreamPaused = true;
+      this.emit(TrackEvent.UpstreamPaused, this);
+      const emptyTrack =
+        this.kind === Track.Kind.Audio ? getEmptyAudioStreamTrack() : getEmptyVideoStreamTrack();
+      await this.sender.replaceTrack(emptyTrack);
+    });
   }
 
   async resumeUpstream() {
-    if (this._isUpstreamPaused === false) {
-      return;
-    }
-    if (!this.sender) {
-      log.warn('unable to resume upstream for an unpublished track');
-      return;
-    }
-    this._isUpstreamPaused = false;
-    this.emit(TrackEvent.UpstreamResumed, this);
-
-    await this.sender.replaceTrack(this._mediaStreamTrack);
+    this.muteQueue.run(async () => {
+      if (this._isUpstreamPaused === false) {
+        return;
+      }
+      if (!this.sender) {
+        log.warn('unable to resume upstream for an unpublished track');
+        return;
+      }
+      this._isUpstreamPaused = false;
+      this.emit(TrackEvent.UpstreamResumed, this);
+
+      await this.sender.replaceTrack(this._mediaStreamTrack);
+    });
   }
 }

package/src/room/track/LocalVideoTrack.ts

@@ -86,21 +86,25 @@ export default class LocalVideoTrack extends LocalTrack {
   }
 
   async mute(): Promise<LocalVideoTrack> {
-    if (this.source === Track.Source.Camera) {
-      log.debug('stopping camera track');
-      // also stop the track, so that camera indicator is turned off
-      this._mediaStreamTrack.stop();
-    }
-    await super.mute();
+    await this.muteQueue.run(async () => {
+      if (this.source === Track.Source.Camera && !this.isUserProvided) {
+        log.debug('stopping camera track');
+        // also stop the track, so that camera indicator is turned off
+        this._mediaStreamTrack.stop();
+      }
+      await super.mute();
+    });
     return this;
   }
 
   async unmute(): Promise<LocalVideoTrack> {
-    if (this.source === Track.Source.Camera && !this.isUserProvided) {
-      log.debug('reacquiring camera track');
-      await this.restartTrack();
-    }
-    await super.unmute();
+    await this.muteQueue.run(async () => {
+      if (this.source === Track.Source.Camera && !this.isUserProvided) {
+        log.debug('reacquiring camera track');
+        await this.restartTrack();
+      }
+      await super.unmute();
+    });
     return this;
   }
 

package/src/room/track/RemoteTrack.ts

@@ -21,6 +21,7 @@ export default abstract class RemoteTrack extends Track {
   setMuted(muted: boolean) {
     if (this.isMuted !== muted) {
       this.isMuted = muted;
+      this._mediaStreamTrack.enabled = !muted;
       this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
     }
   }

package/src/room/track/RemoteTrackPublication.ts

@@ -11,7 +11,7 @@ export default class RemoteTrackPublication extends TrackPublication {
   track?: RemoteTrack;
 
   /** @internal */
-  _allowed = true;
+  protected allowed = true;
 
   // keeps track of client's desire to subscribe to a track
   protected subscribed?: boolean;
@@ -28,6 +28,9 @@ export default class RemoteTrackPublication extends TrackPublication {
    */
   setSubscribed(subscribed: boolean) {
     this.subscribed = subscribed;
+    // reset allowed status when desired subscription state changes
+    // server will notify client via signal message if it's not allowed
+    this.allowed = true;
 
     const sub: UpdateSubscription = {
       trackSids: [this.trackSid],
@@ -46,11 +49,11 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   get subscriptionStatus(): TrackPublication.SubscriptionStatus {
     if (this.subscribed === false || !super.isSubscribed) {
+      if (!this.allowed) {
+        return TrackPublication.SubscriptionStatus.NotAllowed;
+      }
       return TrackPublication.SubscriptionStatus.Unsubscribed;
     }
-    if (!this._allowed) {
-      return TrackPublication.SubscriptionStatus.NotAllowed;
-    }
     return TrackPublication.SubscriptionStatus.Subscribed;
   }
 
@@ -61,9 +64,6 @@ export default class RemoteTrackPublication extends TrackPublication {
     if (this.subscribed === false) {
       return false;
     }
-    if (!this._allowed) {
-      return false;
-    }
     return super.isSubscribed;
   }
 
@@ -127,11 +127,13 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   /** @internal */
   setTrack(track?: Track) {
-    if (this.track) {
+    const prevStatus = this.subscriptionStatus;
+    const prevTrack = this.track;
+    if (prevTrack) {
       // unregister listener
-      this.track.off(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
-      this.track.off(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
-      this.track.off(TrackEvent.Ended, this.handleEnded);
+      prevTrack.off(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
+      prevTrack.off(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
+      prevTrack.off(TrackEvent.Ended, this.handleEnded);
     }
     super.setTrack(track);
     if (track) {
@@ -140,6 +142,22 @@ export default class RemoteTrackPublication extends TrackPublication {
       track.on(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
       track.on(TrackEvent.Ended, this.handleEnded);
     }
+    this.emitSubscriptionUpdateIfChanged(prevStatus);
+    if (!!track !== !!prevTrack) {
+      // when undefined status changes, there's a subscription changed event
+      if (track) {
+        this.emit(TrackEvent.Subscribed, track);
+      } else {
+        this.emit(TrackEvent.Unsubscribed, prevTrack);
+      }
+    }
+  }
+
+  /** @internal */
+  setAllowed(allowed: boolean) {
+    const prevStatus = this.subscriptionStatus;
+    this.allowed = allowed;
+    this.emitSubscriptionUpdateIfChanged(prevStatus);
   }
 
   /** @internal */
@@ -149,6 +167,14 @@ export default class RemoteTrackPublication extends TrackPublication {
     this.track?.setMuted(info.muted);
   }
 
+  private emitSubscriptionUpdateIfChanged(previousStatus: TrackPublication.SubscriptionStatus) {
+    const currentStatus = this.subscriptionStatus;
+    if (previousStatus === currentStatus) {
+      return;
+    }
+    this.emit(TrackEvent.SubscriptionPermissionChanged, currentStatus, previousStatus);
+  }
+
   private isManualOperationAllowed(): boolean {
     if (this.isAdaptiveStream) {
       log.warn('adaptive stream is enabled, cannot change track settings', {

package/src/room/track/Track.ts

@@ -37,6 +37,8 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
 
   protected _mediaStreamTrack: MediaStreamTrack;
 
+  protected _mediaStreamID: string;
+
   protected isInBackground: boolean;
 
   private backgroundTimeout: ReturnType<typeof setTimeout> | undefined;
@@ -47,6 +49,7 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
     super();
     this.kind = kind;
     this._mediaStreamTrack = mediaTrack;
+    this._mediaStreamID = mediaTrack.id;
     this.source = Track.Source.Unknown;
     if (isWeb()) {
       this.isInBackground = document.visibilityState === 'hidden';
@@ -65,6 +68,15 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
     return this._mediaStreamTrack;
   }
 
+  /**
+   * @internal
+   * used for keep mediaStream's first id, since it's id might change
+   * if we disable/enable a track
+   */
+  get mediaStreamID(): string {
+    return this._mediaStreamID;
+  }
+
   /**
    * creates a new HTMLAudioElement or HTMLVideoElement, attaches to it, and returns it
    */

package/src/room/track/TrackPublication.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'events';
+import log from '../../logger';
 import { TrackInfo } from '../../proto/livekit_models';
 import { TrackEvent } from '../events';
 import LocalAudioTrack from './LocalAudioTrack';
@@ -108,6 +109,7 @@ export class TrackPublication extends EventEmitter {
       this.simulcasted = info.simulcast;
     }
     this.trackInfo = info;
+    log.trace('update publication info', { info });
   }
 }
 

package/dist/src/api/RequestQueue.d.ts

@@ -1,13 +0,0 @@
-export default class Queue {
-    private queue;
-    private running;
-    constructor();
-    enqueue(cb: () => void): void;
-    dequeue(): void;
-    run(): Promise<void>;
-    pause(): void;
-    reset(): void;
-    isRunning(): boolean;
-    isEmpty(): boolean;
-}
-//# sourceMappingURL=RequestQueue.d.ts.map

package/dist/src/api/RequestQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RequestQueue.d.ts","sourceRoot":"","sources":["../../../src/api/RequestQueue.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,OAAO,CAAC,KAAK,CAAoB;IAEjC,OAAO,CAAC,OAAO,CAAU;;IAOzB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI;IAKtB,OAAO;IAMD,GAAG;IAWT,KAAK;IAKL,KAAK;IAML,SAAS;IAIT,OAAO;CAGR"}

package/src/api/RequestQueue.ts

@@ -1,53 +0,0 @@
-import log from '../logger';
-
-export default class Queue {
-  private queue: Array<() => void>;
-
-  private running: boolean;
-
-  constructor() {
-    this.queue = [];
-    this.running = false;
-  }
-
-  enqueue(cb: () => void) {
-    log.trace('enqueuing request to fire later');
-    this.queue.push(cb);
-  }
-
-  dequeue() {
-    const evt = this.queue.shift();
-    if (evt) evt();
-    log.trace('firing request from queue');
-  }
-
-  async run() {
-    if (this.running) return;
-    log.trace('start queue');
-    this.running = true;
-    while (this.running && this.queue.length > 0) {
-      this.dequeue();
-    }
-    this.running = false;
-    log.trace('queue finished');
-  }
-
-  pause() {
-    log.trace('pausing queue');
-    this.running = false;
-  }
-
-  reset() {
-    log.trace('resetting queue');
-    this.running = false;
-    this.queue = [];
-  }
-
-  isRunning() {
-    return this.running;
-  }
-
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-}