@livedigital/client 2.32.0 → 2.32.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.32.0",
+  "version": "2.32.2",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -40,6 +40,7 @@
     ]
   },
   "dependencies": {
+    "async-mutex": "^0.3.2",
     "awaitqueue": "^2.4.0",
     "axios": "^0.21.4",
     "debug": "^4.3.1",

package/src/engine/Peer.ts

@@ -228,7 +228,7 @@ class Peer {
       }
 
       track.setIsTrackProducerPaused(true);
-      await track.pause();
+      await track.pause(false);
     });
 
     this.observer.on(MEDIASOUP_EVENTS.resumeConsumer, async (consumerId) => {
@@ -238,7 +238,7 @@ class Peer {
       }
 
       track.setIsTrackProducerPaused(false);
-      await track.resume();
+      await track.resume(false);
     });
 
     // set outgoing connection quality for remote peer

package/src/engine/media/index.ts

@@ -117,8 +117,14 @@ class Media {
     return Array.from(this.tracks.values());
   }
 
-  clearTracks(): void {
-    this.tracks.clear();
+  async clearTracks(): Promise<void> {
+    try {
+      this.getAllTracks().map((track) => track.stopMediaStreamTrack());
+    } catch (error) {
+      this.#logger.warn('clearTracks()', { error });
+    } finally {
+      this.tracks.clear();
+    }
   }
 
   static getScreenVideoTrackParams(options?: CreateScreenVideoTrackOptions): CreateVideoTrackParams {

package/src/engine/media/tracks/BaseTrack.ts

@@ -1,5 +1,6 @@
 import { Producer } from 'mediasoup-client/lib/Producer';
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import { Mutex } from 'async-mutex';
 import {
   BaseTrackInfo,
   EncoderConfig,
@@ -56,6 +57,8 @@ class BaseTrack {
 
   #stopTrackOnPause = true;
 
+  #mutex = new Mutex();
+
   constructor(params: BaseTrackConstructorParams) {
     const {
       mediaStreamTrack, logLevel, engine, clientEventEmitter, constraints, mediaStreamTrackManager,
@@ -162,6 +165,10 @@ class BaseTrack {
     });
   }
 
+  stopMediaStreamTrack(): void {
+    this.mediaStreamTrack.stop();
+  }
+
   private async checkProducerState(): Promise<void> {
     try {
       if (this.#closed || this.kind === 'audio') {
@@ -379,6 +386,9 @@ class BaseTrack {
   }
 
   public async pause(): Promise<void> {
+    await this.#mutex.waitForUnlock();
+    const release = await this.#mutex.acquire();
+
     if (!this.producer) {
       this.logger.warn('pause()', { message: 'Track is not published', track: this });
       return;
@@ -400,10 +410,15 @@ class BaseTrack {
     } catch (error) {
       this.logger.error('pause()', { error, track: this });
       throw new Error('Can`t pause track');
+    } finally {
+      release();
     }
   }
 
   public async resume(): Promise<void> {
+    await this.#mutex.waitForUnlock();
+    const release = await this.#mutex.acquire();
+
     if (!this.producer) {
       this.logger.warn('resume()', { message: 'Track is not published', track: this });
       return;
@@ -423,6 +438,8 @@ class BaseTrack {
     } catch (error) {
       this.logger.error('resume()', { error, track: this });
       throw new Error('Can`t resume track');
+    } finally {
+      release();
     }
   }
 

package/src/engine/media/tracks/PeerTrack.ts

@@ -1,4 +1,5 @@
 import { MediaKind } from 'mediasoup-client/lib/types';
+import { AwaitQueue } from 'awaitqueue';
 import {
   PreferredLayersParams,
   SetConsumerPriorityParams,
@@ -50,6 +51,8 @@ class PeerTrack {
 
   #isTrackProducerPaused?: boolean;
 
+  #queue = new AwaitQueue();
+
   constructor(payload: PeerTrackConstructor) {
     this.#mediaStreamTrack = payload.mediaStreamTrack;
     this.label = payload.label;
@@ -101,59 +104,73 @@ class PeerTrack {
     this.clearCheckStateTimeout();
   }
 
-  public async pause(): Promise<void> {
-    if (!this.consumer) {
-      this.#paused = true;
-      this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackPaused, this);
-      return;
-    }
+  public async pause(pauseRemote = true): Promise<void> {
+    await this.#queue.push(async () => {
+      if (!this.consumer) {
+        this.#paused = true;
+        this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackPaused, this);
+        return;
+      }
 
-    if (this.#paused) {
-      this.#logger.debug('pause()', { message: 'Already paused', peer: this, consumer: this.consumer });
-      return;
-    }
+      if (this.#paused) {
+        this.#logger.debug('pause()', { message: 'Already paused', peer: this, consumer: this.consumer });
+        return;
+      }
 
-    try {
-      this.clearCheckStateTimeout();
-      await this.#engine.network.pauseRemoteConsumer(this.consumer.id);
-      this.consumer.pause();
-      this.#paused = true;
-      this.#consumerRestarted = false;
-      this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackPaused, this);
-      this.#logger.debug('pause()', { peer: this, consumer: this.consumer });
-    } catch (error) {
-      this.#logger.warn('pause()', { error });
-    }
+      try {
+        this.clearCheckStateTimeout();
+        if (pauseRemote) {
+          await this.#engine.network.pauseRemoteConsumer(this.consumer.id);
+        }
+
+        this.consumer.pause();
+        this.#paused = true;
+        this.#consumerRestarted = false;
+        this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackPaused, this);
+        this.#logger.debug('pause()', { peer: this, consumer: this.consumer });
+      } catch (error) {
+        this.#logger.warn('pause()', { error });
+      }
+    });
   }
 
-  public async resume(): Promise<void> {
-    if (!this.consumer) {
-      this.#paused = false;
-      this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackResumed, this);
-      this.#logger.debug('resume()', { track: this, peer: this });
-      return;
-    }
+  public async resume(resumeRemote = true): Promise<void> {
+    await this.#queue.push(async () => {
+      if (!this.consumer) {
+        this.#paused = false;
+        this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackResumed, this);
+        this.#logger.debug('resume()', { track: this, peer: this });
+        return;
+      }
 
-    if (!this.#paused) {
-      this.#logger.debug('resume()', { message: 'Already playing', track: this, peer: this });
-      return;
-    }
+      if (!this.#paused) {
+        this.#logger.debug('resume()', { message: 'Already playing', track: this, peer: this });
+        return;
+      }
 
-    if (this.#isTrackProducerPaused) {
-      this.#logger.debug('resume()', { message: 'Can not resume track, producer is paused', track: this, peer: this });
-      return;
-    }
+      if (this.#isTrackProducerPaused) {
+        this.#logger.debug('resume()', {
+          message: 'Can not resume track, producer is paused',
+          track: this,
+          peer: this,
+        });
+        return;
+      }
 
-    try {
-      await this.#engine.network.resumeRemoteConsumer(this.consumer.id);
-      this.consumer.resume();
-      this.#paused = false;
-      this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackResumed, this);
-      this.checkConsumerState();
-      this.#logger.debug('resume()', { track: this, peer: this });
-    } catch (error) {
-      this.#logger.warn('resume()', { error });
-    }
+      try {
+        if (resumeRemote) {
+          await this.#engine.network.resumeRemoteConsumer(this.consumer.id);
+        }
+
+        this.consumer.resume();
+        this.#paused = false;
+        this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackResumed, this);
+        this.checkConsumerState();
+        this.#logger.debug('resume()', { track: this, peer: this });
+      } catch (error) {
+        this.#logger.warn('resume()', { error });
+      }
+    });
   }
 
   public async setPriority(priority: number): Promise<void> {

package/src/engine/system/index.ts

@@ -108,14 +108,14 @@ class System {
     try {
       await this.requestMediaDevicesAccess();
     } catch (errorVideoAndAudio) {
-      if (errorVideoAndAudio.message !== DeviceErrors.NotFoundError) {
+      if (![DeviceErrors.NotFoundError, DeviceErrors.NotAllowedError].includes(errorVideoAndAudio.message)) {
         throw errorVideoAndAudio;
       }
 
       try {
         await this.requestMediaDevicesAccess({ audio: true });
       } catch (errorAudioOnly) {
-        if (errorAudioOnly.message !== DeviceErrors.NotFoundError) {
+        if (![DeviceErrors.NotFoundError, DeviceErrors.NotAllowedError].includes(errorAudioOnly.message)) {
           throw errorAudioOnly;
         }