@livedigital/client 2.32.2 → 2.33.0

package/dist/types/common.d.ts

@@ -176,7 +176,7 @@ export declare type PayloadOfPublishedMedia = {
 };
 export declare type SubscribeOptions = {
     producerId: string;
-    paused?: boolean;
+    muted?: boolean;
 };
 export declare type PayloadOfUnpublishedMedia = PayloadOfPublishedMedia;
 export declare type ChangePreferredLayersPayload = PreferredLayersParams & {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.32.2",
+  "version": "2.33.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/Peer.ts

@@ -119,7 +119,7 @@ class Peer {
     }));
   }
 
-  public async subscribe({ producerId, paused = false }: SubscribeOptions): Promise<void> {
+  public async subscribe({ producerId, muted = false }: SubscribeOptions): Promise<void> {
     try {
       const producer = this.producers.get(producerId);
       if (!producer) {
@@ -146,13 +146,13 @@ class Peer {
         label: producer.label,
         consumer: new PeerConsumer({ consumer, logLevel: this.engine.logLevel }),
         engine: this.engine,
-        isPaused: true,
+        muted,
+        paused: isProducerPaused,
         peerEventEmitter: this.observer,
-        isProducerPaused,
       });
 
-      if (!paused) {
-        await track.resume();
+      if (!muted) {
+        await track.unmute();
       }
 
       this.tracks.set(track.label, track);
@@ -227,7 +227,6 @@ class Peer {
         return;
       }
 
-      track.setIsTrackProducerPaused(true);
       await track.pause(false);
     });
 
@@ -237,7 +236,6 @@ class Peer {
         return;
       }
 
-      track.setIsTrackProducerPaused(false);
       await track.resume(false);
     });
 

package/src/engine/index.ts

@@ -525,7 +525,8 @@ class Engine {
       mediaStreamTrack: track.mediaStreamTrack,
       label: track.getLabel(),
       engine: this,
-      isPaused: track.isPaused,
+      muted: false,
+      paused: track.isPaused,
       peerEventEmitter: myPeer.observer,
     });
 

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

@@ -22,8 +22,8 @@ interface PeerTrackConstructor {
   label: TrackLabel,
   consumer?: PeerConsumer,
   engine: Engine,
-  isPaused: boolean,
-  isProducerPaused?: boolean,
+  muted: boolean,
+  paused: boolean,
   peerEventEmitter: EnhancedEventEmitter,
   onLogMessage?: LogMessageHandler,
 }
@@ -49,10 +49,12 @@ class PeerTrack {
 
   #closed = false;
 
-  #isTrackProducerPaused?: boolean;
-
   #queue = new AwaitQueue();
 
+  #muted = false;
+
+  readonly observer = new EnhancedEventEmitter();
+
   constructor(payload: PeerTrackConstructor) {
     this.#mediaStreamTrack = payload.mediaStreamTrack;
     this.label = payload.label;
@@ -64,8 +66,8 @@ class PeerTrack {
       onLogMessage: payload.onLogMessage,
     });
     this.#peerEventEmitter = payload.peerEventEmitter;
-    this.#paused = payload.isPaused;
-    this.#isTrackProducerPaused = payload.isProducerPaused;
+    this.#muted = payload.muted;
+    this.#paused = payload.paused;
     this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackStart, this);
   }
 
@@ -85,6 +87,10 @@ class PeerTrack {
     return this.#paused;
   }
 
+  get isMuted(): boolean {
+    return this.#muted;
+  }
+
   get consumerId(): string | undefined {
     return this.consumer?.id;
   }
@@ -104,11 +110,28 @@ class PeerTrack {
     this.clearCheckStateTimeout();
   }
 
+  public async mute(): Promise<void> {
+    await this.#queue.push(async () => {
+      this.#logger.debug('mute()', { track: this, peer: this });
+      await this.pauseConsumer();
+      this.#muted = true;
+    });
+  }
+
+  public async unmute(): Promise<void> {
+    await this.#queue.push(async () => {
+      this.#logger.debug('unmute()', { track: this, peer: this });
+      await this.resumeConsumer();
+      this.#muted = false;
+    });
+  }
+
   public async pause(pauseRemote = true): Promise<void> {
     await this.#queue.push(async () => {
-      if (!this.consumer) {
+      if (!this.consumer || this.isMuted) {
         this.#paused = true;
         this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackPaused, this);
+        this.#logger.debug('pause()', { track: this, peer: this });
         return;
       }
 
@@ -117,26 +140,15 @@ class PeerTrack {
         return;
       }
 
-      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 });
-      }
+      await this.pauseConsumer(pauseRemote);
+      this.#paused = true;
+      this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackPaused, this);
     });
   }
 
   public async resume(resumeRemote = true): Promise<void> {
     await this.#queue.push(async () => {
-      if (!this.consumer) {
+      if (!this.consumer || this.isMuted) {
         this.#paused = false;
         this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackResumed, this);
         this.#logger.debug('resume()', { track: this, peer: this });
@@ -148,28 +160,9 @@ class PeerTrack {
         return;
       }
 
-      if (this.#isTrackProducerPaused) {
-        this.#logger.debug('resume()', {
-          message: 'Can not resume track, producer is paused',
-          track: this,
-          peer: this,
-        });
-        return;
-      }
-
-      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 });
-      }
+      await this.resumeConsumer(resumeRemote);
+      this.#paused = false;
+      this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackResumed, this);
     });
   }
 
@@ -181,6 +174,43 @@ class PeerTrack {
     await this.setConsumerPriority({ consumerId: this.consumer.id, priority });
   }
 
+  private async resumeConsumer(resumeRemote = true): Promise<void> {
+    if (!this.consumer) {
+      return;
+    }
+
+    try {
+      if (resumeRemote) {
+        await this.#engine.network.resumeRemoteConsumer(this.consumer.id);
+      }
+
+      this.consumer.resume();
+      this.checkConsumerState();
+      this.#logger.debug('resumeConsumer()', { track: this, peer: this });
+    } catch (error) {
+      this.#logger.warn('resumeConsumer()', { error });
+    }
+  }
+
+  private async pauseConsumer(pauseRemote = true): Promise<void> {
+    if (!this.consumer) {
+      return;
+    }
+
+    try {
+      this.clearCheckStateTimeout();
+      if (pauseRemote) {
+        await this.#engine.network.pauseRemoteConsumer(this.consumer.id);
+      }
+
+      this.consumer.pause();
+      this.#consumerRestarted = false;
+      this.#logger.debug('pauseConsumer()', { peer: this, consumer: this.consumer });
+    } catch (error) {
+      this.#logger.warn('pauseConsumer()', { error });
+    }
+  }
+
   private async setConsumerPriority(params: SetConsumerPriorityParams): Promise<void> {
     try {
       await this.#engine.network.socket.request(MEDIASOUP_EVENTS.setConsumerPriority, params);
@@ -458,10 +488,6 @@ class PeerTrack {
 
     clearTimeout(this.#checkStateTimeout);
   }
-
-  setIsTrackProducerPaused(value: boolean): void {
-    this.#isTrackProducerPaused = value;
-  }
 }
 
 export default PeerTrack;

package/src/types/common.ts

@@ -212,7 +212,7 @@ export type PayloadOfPublishedMedia = {
 
 export type SubscribeOptions = {
   producerId: string,
-  paused?: boolean,
+  muted?: boolean,
 };
 
 export type PayloadOfUnpublishedMedia = PayloadOfPublishedMedia;