livekit-client 1.1.6 → 1.1.9

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');
@@ -170,6 +176,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 +222,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/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;
-  }
-}