@livedigital/client 1.7.0 → 1.10.0

package/src/engine/Peer.ts

@@ -1,13 +1,15 @@
 import { ConsumerOptions } from 'mediasoup-client/lib/Consumer';
 import {
-  ChangePreferredLayersParams,
   ConsumerScoreChangedPayload,
   PreferredLayersParams,
   ProducerData,
-  ProducerKind,
   ProducerScoreChangedPayload,
   SetConsumerPriorityParams,
   SocketResponse,
+  ConnectionQuality,
+  StartTrackPayload,
+  EndTrackPayload,
+  PayloadOfPublishedMedia, PayloadOfUnpublishedMedia,
 } from '../types/common';
 import Consumer from './media/Consumer';
 import VideoConsumer from './media/VideoConsumer';
@@ -16,7 +18,6 @@ import Engine from './index';
 import { MEDIASOUP_EVENTS, PEER_EVENTS } from '../constants/events';
 import Logger from './Logger';
 import PeerProducer from './PeerProducer';
-import { ConnectionQuality } from '../types/common';
 
 interface PeerConstructor {
   id: string;
@@ -51,13 +52,9 @@ class Peer {
 
   public appData: Record<string, unknown>;
 
-  private videoProducer?: PeerProducer;
+  private producers: Map<string, PeerProducer> = new Map();
 
-  private audioProducer?: PeerProducer;
-
-  private videoConsumer?: VideoConsumer;
-
-  private audioConsumer?: Consumer;
+  private consumers: Map<string, Consumer | VideoConsumer> = new Map();
 
   private readonly engine: Engine;
 
@@ -75,8 +72,6 @@ class Peer {
     appId,
     loginDate = new Date(),
     producers = [],
-    videoConsumer,
-    audioConsumer,
     engine,
     appData,
     uid,
@@ -88,8 +83,6 @@ class Peer {
     this.appData = appData || {};
     this.uid = uid;
     this.engine = engine;
-    this.videoConsumer = videoConsumer;
-    this.audioConsumer = audioConsumer;
     this.logger = new Logger('Peer');
     producers.forEach(this.handleNewProducer.bind(this));
     this.handlePeerEvents();
@@ -99,245 +92,121 @@ class Peer {
     return this._observer;
   }
 
-  public get isPublishedVideo(): boolean {
-    return !!this.videoProducer;
-  }
-
-  public get isPublishedAudio(): boolean {
-    return !!this.audioProducer;
-  }
-
-  public get hasVideo(): boolean {
-    return !!this.videoConsumer;
-  }
-
-  public get hasAudio(): boolean {
-    return !!this.audioConsumer;
-  }
-
-  public get videoTrack(): MediaStreamTrack | undefined {
-    if (this.isMe) {
-      return this.engine.system.videoStream?.getVideoTracks()[0];
-    }
-
-    return this.videoConsumer?.track;
-  }
-
-  public get audioTrack(): MediaStreamTrack | undefined {
-    if (this.isMe) {
-      return this.engine.system.audioStream?.getVideoTracks()[0];
-    }
-
-    return this.audioConsumer?.track;
-  }
-
-  public get isVideoPaused(): boolean {
-    return this.videoConsumer?.paused || false;
-  }
-
-  public get isAudioPaused(): boolean {
-    return this.audioConsumer?.paused || false;
-  }
-
-  public get videoCodec(): string | undefined {
-    if (!this.videoConsumer) {
-      return undefined;
-    }
-
-    return this.videoConsumer.rtpParameters.codecs[0].mimeType.split('/')[1];
-  }
-
-  public get audioCodec(): string | undefined {
-    if (!this.audioConsumer) {
-      return undefined;
-    }
-
-    return this.audioConsumer.rtpParameters.codecs[0].mimeType.split('/')[1];
-  }
-
   public get isMe(): boolean {
     return this.id === this.engine.mySocketId;
   }
 
-  public async subscribeVideo(): Promise<void> {
-    if (!this.videoProducer) {
-      this.logger.warn('subscribeVideo()', { message: 'This peer has no published video', peer: this });
-      return;
-    }
-
-    if (this.videoConsumer) {
-      this.logger.warn('subscribeVideo()', { message: 'Already subscribed this peer\'s video', peer: this });
-      return;
-    }
-
-    await this.createConsumer(this.videoProducer);
-  }
-
-  public async subscribeAudio(): Promise<void> {
-    if (!this.audioProducer) {
-      this.logger.warn('subscribeAudio()', { message: 'This peer has no published audio', peer: this });
-      return;
-    }
-
-    if (this.audioConsumer) {
-      this.logger.warn('subscribeAudio()', { message: 'Already subscribed this peer\'s audio', peer: this });
-      return;
-    }
-
-    await this.createConsumer(this.audioProducer);
+  public get publishedMedia(): PayloadOfPublishedMedia[] {
+    return Array.from(this.producers.values()).map((producer) => ({
+      producerId: producer.id,
+      kind: producer.kind,
+      label: producer.label,
+    }));
   }
 
-  public async unSubscribeVideo(): Promise<void> {
-    if (!this.videoConsumer) {
-      this.logger.warn('unSubscribeVideo()', { message: 'This peer has no subscribed video', peer: this });
+  public async subscribe(producerId: string): Promise<void> {
+    const producer = this.producers.get(producerId);
+    if (!producer) {
+      this.logger.warn('subscribe()', { message: 'Peer does not have a producer', peer: this, producerId });
       return;
     }
 
-    await this.closeConsumer(this.videoConsumer);
-    this.videoConsumer = undefined;
-    this.observer.safeEmit('track-end', { kind: 'video' });
-  }
-
-  public async unSubscribeAudio(): Promise<void> {
-    if (!this.audioConsumer) {
-      this.logger.warn('unSubscribeAudio()', { message: 'This peer has no subscribed audio', peer: this });
+    const consumer = this.getAllConsumers().find((item) => item.producerId === producerId);
+    if (consumer) {
+      this.logger.warn('subscribe()', { message: 'Already subscribed to producer', peer: this, producerId });
       return;
     }
 
-    await this.closeConsumer(this.audioConsumer);
-    this.audioConsumer = undefined;
-    this.observer.safeEmit('track-end', { kind: 'audio' });
+    await this.createConsumer(producer);
   }
 
-  public async setMinResolution(): Promise<void> {
-    if (!this.videoConsumer || this.videoConsumer?.spatialLayers === 0) {
+  public async setMinResolution(consumerId: string): Promise<void> {
+    const consumer = this.consumers.get(consumerId);
+    if (!(consumer instanceof VideoConsumer) || consumer.spatialLayers === 0) {
       return;
     }
 
-    await this.changeConsumerPreferredLayers({
-      spatialLayer: 0,
-    });
+    await this.changeConsumerPreferredLayers(consumer, { spatialLayer: 0 });
   }
 
-  public async setMediumResolution(): Promise<void> {
-    if (!this.videoConsumer || this.videoConsumer?.spatialLayers === 0) {
+  public async setMediumResolution(consumerId: string): Promise<void> {
+    const consumer = this.consumers.get(consumerId);
+    if (!(consumer instanceof VideoConsumer) || consumer.spatialLayers === 0) {
       return;
     }
 
-    const mediumLayer = this.videoConsumer.spatialLayers > 2
-      ? this.videoConsumer.spatialLayers - 2
-      : this.videoConsumer.spatialLayers;
-
-    await this.changeConsumerPreferredLayers({
-      spatialLayer: mediumLayer,
-    });
+    const mediumLayer = consumer.spatialLayers > 2
+      ? consumer.spatialLayers - 2
+      : consumer.spatialLayers;
+    await this.changeConsumerPreferredLayers(consumer, { spatialLayer: mediumLayer });
   }
 
-  public async setMaxResolution(): Promise<void> {
-    if (!this.videoConsumer || this.videoConsumer.spatialLayers === 0) {
+  public async setMaxResolution(consumerId: string): Promise<void> {
+    const consumer = this.consumers.get(consumerId);
+    if (!(consumer instanceof VideoConsumer) || consumer.spatialLayers === 0) {
       return;
     }
 
-    await this.changeConsumerPreferredLayers({
-      spatialLayer: this.videoConsumer.spatialLayers - 1,
+    await this.changeConsumerPreferredLayers(consumer, {
+      spatialLayer: consumer.spatialLayers - 1,
     });
   }
 
-  public async pauseVideo(): Promise<void> {
-    if (!this.videoConsumer) {
-      this.logger.warn('pauseVideo()', { message: 'This peer has no subscribed video', peer: this });
-      return;
-    }
-
-    if (this.videoConsumer.paused) {
-      this.logger.warn('pauseVideo()', { message: 'Already paused', peer: this });
-      return;
-    }
-
-    try {
-      await this.pauseRemoteConsumer(this.videoConsumer?.id);
-      this.videoConsumer.pause();
-      this.logger.debug('pauseVideo()', { peer: this });
-    } catch (err) {
-      this.logger.error('pauseVideo()', err);
-    }
-  }
-
-  public async pauseAudio(): Promise<void> {
-    if (!this.audioConsumer) {
-      this.logger.warn('pauseAudio()', { message: 'This peer has no subscribed audio', peer: this });
+  public async pause(consumerId: string): Promise<void> {
+    const consumer = this.consumers.get(consumerId);
+    if (!consumer) {
+      this.logger.warn('pause()', { message: 'This peer has no consumer to pause', peer: this, consumerId });
       return;
     }
 
-    if (this.audioConsumer.paused) {
-      this.logger.warn('pauseAudio()', { message: 'Already paused', peer: this });
+    if (consumer.paused) {
+      this.logger.warn('pause()', { message: 'Already paused', peer: this, consumerId });
       return;
     }
 
     try {
-      await this.pauseRemoteConsumer(this.audioConsumer?.id);
-      this.audioConsumer.pause();
-      this.logger.debug('pauseAudio()', { peer: this });
+      await this.pauseRemoteConsumer(consumer.id);
+      consumer.pause();
+      this.logger.debug('pause()', { peer: this, consumerId });
     } catch (err) {
-      this.logger.error('pauseAudio()', err);
+      this.logger.error('pause()', err);
     }
   }
 
-  public async resumeVideo(): Promise<void> {
-    if (!this.videoConsumer) {
-      this.logger.warn('resumeVideo()', { message: 'This peer has no subscribed video', peer: this });
+  public async resume(consumerId: string): Promise<void> {
+    const consumer = this.consumers.get(consumerId);
+    if (!consumer) {
+      this.logger.warn('resume()', { message: 'This peer has no consumer to resume', peer: this, consumerId });
       return;
     }
 
-    if (!this.videoConsumer.paused) {
-      this.logger.warn('resumeVideo()', { message: 'Video is not paused', peer: this });
+    if (!consumer.paused) {
+      this.logger.warn('resume()', { message: 'Already playing', peer: this, consumerId });
       return;
     }
 
     try {
-      await this.resumeRemoteConsumer(this.videoConsumer?.id);
-      this.videoConsumer.resume();
-      this.logger.debug('resumeVideo()', { peer: this });
+      await this.resumeRemoteConsumer(consumer.id);
+      consumer.resume();
+      this.logger.debug('resume()', { peer: this });
     } catch (err) {
-      this.logger.error('resumeVideo()', err);
+      this.logger.error('resume()', err);
     }
   }
 
-  public async resumeAudio(): Promise<void> {
-    if (!this.audioConsumer) {
-      this.logger.warn('resumeAudio()', { message: 'This peer has no subscribed audio', peer: this });
-      return;
-    }
-
-    if (this.audioConsumer.paused) {
-      this.logger.warn('resumeAudio()', { message: 'Audio is not paused', peer: this });
-      return;
-    }
-    try {
-      await this.resumeRemoteConsumer(this.audioConsumer?.id);
-      this.audioConsumer.resume();
-      this.logger.debug('resumeAudio()', { peer: this });
-    } catch (err) {
-      this.logger.error('resumeAudio()', err);
-    }
-  }
-
-  public async setVideoStreamPriority(priority: number): Promise<void> {
-    if (!this.videoConsumer) {
-      this.logger.warn('setVideoStreamPriority()', { message: 'This peer has no subscribed audio', peer: this });
-      return;
-    }
-
-    await this.setConsumerPriority({ consumerId: this.videoConsumer.id, priority });
-  }
+  public async setPriority(consumerId: string, priority: number): Promise<void> {
+    const consumer = this.consumers.get(consumerId);
+    if (!consumer) {
+      this.logger.warn('setPriority()', {
+        message: 'This peer has no consumer to change priority',
+        peer: this,
+        consumerId,
+      });
 
-  public async setAudioStreamPriority(priority: number): Promise<void> {
-    if (!this.audioConsumer) {
-      this.logger.warn('setAudioStreamPriority()', { message: 'This peer has no subscribed audio', peer: this });
       return;
     }
 
-    await this.setConsumerPriority({ consumerId: this.audioConsumer.id, priority });
+    await this.setConsumerPriority({ consumerId, priority });
   }
 
   private async setConsumerPriority(params: SetConsumerPriorityParams): Promise<void> {
@@ -372,91 +241,46 @@ class Peer {
       await this.engine.network.socket.request(MEDIASOUP_EVENTS.resumeConsumer, { consumerId: consumer.id });
 
       if (producer.kind === 'audio') {
-        this.audioConsumer = new Consumer(consumer);
+        this.consumers.set(consumer.id, new Consumer(consumer));
       }
 
       if (producer.kind === 'video') {
-        this.videoConsumer = new VideoConsumer(consumer);
+        this.consumers.set(consumer.id, new VideoConsumer(consumer));
       }
 
       this.logger.debug(`Subscribed for ${producer.kind}`, { peer: this });
-      this.observer.safeEmit(PEER_EVENTS.trackStart, { kind: producer.kind, track: consumer.track });
+      this.observer.safeEmit(PEER_EVENTS.trackStart, {
+        producerId: producer.id,
+        consumerId: consumer.id,
+        track: consumer.track,
+        label: producer.label,
+      } as StartTrackPayload);
     } catch (error) {
       this.logger.error('createConsumer()', producer, error);
       throw new Error('Error subscribe media');
     }
   }
 
-  private async closeConsumer(consumer: Consumer | VideoConsumer): Promise<void> {
-    try {
-      await this.engine.network.socket.request(MEDIASOUP_EVENTS.closeConsumer, {
-        peerId: this.engine.mySocketId,
-        consumerId: consumer.id,
-      });
-
-      consumer.close();
-      this.logger.warn('Unsubscribed media', { peer: this, kind: consumer.kind });
-    } catch (err) {
-      this.logger.debug('closeConsumer()', { peer: this, consumer, error: err });
-      throw new Error('Error unsubscribe media');
-    }
-  }
-
-  private async changeConsumerPreferredLayers({ spatialLayer, temporalLayer }: PreferredLayersParams): Promise<void> {
-    if (!this.videoConsumer) {
-      return;
-    }
-
-    const {
-      spatialLayer: oldSpatialLayer,
-      temporalLayer: oldTemporalLayer,
-    } = this.videoConsumer.currentPreferredLayers;
-
-    if (oldSpatialLayer === spatialLayer || oldTemporalLayer === temporalLayer) {
-      return;
-    }
-
+  private async changeConsumerPreferredLayers(
+    consumer: VideoConsumer,
+    { spatialLayer, temporalLayer }: PreferredLayersParams,
+  ): Promise<void> {
     try {
-      this.videoConsumer.currentPreferredLayers = { spatialLayer, temporalLayer };
       await this.engine.network.socket.request(MEDIASOUP_EVENTS.consumerChangePreferredLayers, {
-        consumerId: this.videoConsumer.id,
+        consumerId: consumer.id,
         spatialLayer,
         temporalLayer,
       });
     } catch (err) {
       this.logger.error('changeConsumerPreferredLayers()', {
         peer: this,
-        consumer: this.videoConsumer,
+        consumer,
         error: err,
       });
       throw new Error('Error change preferred layer');
     }
   }
 
-  private setVideoProducer(producer: PeerProducer): void {
-    if (producer.kind !== 'video') {
-      throw new Error('Error kind of producer');
-    }
-
-    this.videoProducer = producer;
-  }
-
-  private setAudioProducer(producer: PeerProducer): void {
-    if (producer.kind !== 'audio') {
-      throw new Error('Error kind of producer');
-    }
-
-    this.audioProducer = producer;
-  }
-
-  private removeVideoProducer(): void {
-    this.videoProducer = undefined;
-  }
-
-  private removeAudioProducer(): void {
-    this.audioProducer = undefined;
-  }
-
   private async pauseRemoteConsumer(consumerId: string): Promise<SocketResponse> {
     return this.engine.network.socket.request(MEDIASOUP_EVENTS.pauseConsumer, { consumerId });
   }
@@ -467,87 +291,62 @@ class Peer {
 
   private handleNewProducer(producerData: ProducerData): void {
     const producer = new PeerProducer(producerData);
-    if (producer.kind === ProducerKind.VIDEO) {
-      this.setVideoProducer(producer);
-    } else {
-      this.setAudioProducer(producer);
-    }
-
+    this.producers.set(producer.id, producer);
     this.logger.debug('Peer published media:', { peer: this, producer });
-    this.observer.safeEmit(PEER_EVENTS.mediaPublished, { kind: producer.kind });
+    this.observer.safeEmit(PEER_EVENTS.mediaPublished, {
+      producerId: producer.id,
+      kind: producer.kind,
+      label: producer.label,
+    } as PayloadOfPublishedMedia);
   }
 
   private handlePeerEvents(): void {
     this.observer.on(MEDIASOUP_EVENTS.newProducer, this.handleNewProducer.bind(this));
 
     this.observer.on(MEDIASOUP_EVENTS.producerClose, (producer: ProducerData) => {
-      if (producer.kind === ProducerKind.VIDEO) {
-        this.removeVideoProducer();
-      } else {
-        this.removeAudioProducer();
-      }
-
+      this.producers.delete(producer.id);
       this.logger.debug('Peer unpublished media:', { peer: this, producer });
-      this.observer.safeEmit(PEER_EVENTS.mediaUnPublished, { kind: producer.kind });
+      this.observer.safeEmit(PEER_EVENTS.mediaUnPublished, {
+        producerId: producer.id,
+        kind: producer.kind,
+        label: producer.label,
+      } as PayloadOfUnpublishedMedia);
     });
 
     this.observer.on(MEDIASOUP_EVENTS.closeConsumer, (consumerId) => {
-      if (this.videoConsumer?.id === consumerId) {
-        this.videoConsumer?.close();
-        this.videoConsumer = undefined;
-        this.observer.safeEmit(PEER_EVENTS.trackEnd, { kind: 'video' });
-        this.logger.debug('Peer video track was ended:', { peer: this });
+      const consumer = this.consumers.get(consumerId);
+      if (!consumer) {
         return;
       }
 
-      if (this.audioConsumer?.id === consumerId) {
-        this.audioConsumer?.close();
-        this.audioConsumer = undefined;
-        this.logger.debug('Peer audio track was ended:', { peer: this });
-        this.observer.safeEmit(PEER_EVENTS.trackEnd, { kind: 'audio' });
-      }
+      consumer.close();
+      this.consumers.delete(consumerId);
+      this.observer.safeEmit(PEER_EVENTS.trackEnd, {
+        producerId: consumer.producerId,
+        kind: consumer.kind,
+        label: consumer.appData.producerData.label,
+      } as EndTrackPayload);
+      this.logger.debug('Peer video track was ended:', { peer: this });
     });
 
     this.observer.on(MEDIASOUP_EVENTS.pauseConsumer, (consumerId) => {
-      if (this.videoConsumer?.id === consumerId) {
-        this.videoConsumer?.pause();
-        this.logger.debug('Peer video track was paused:', { peer: this });
+      const consumer = this.consumers.get(consumerId);
+      if (!consumer) {
         return;
       }
 
-      if (this.audioConsumer?.id === consumerId) {
-        this.audioConsumer?.pause();
-        this.logger.debug('Peer audio track was paused:', { peer: this });
-      }
+      consumer.pause();
+      this.logger.debug('Peer video track was paused:', { peer: this });
     });
 
     this.observer.on(MEDIASOUP_EVENTS.resumeConsumer, (consumerId) => {
-      if (this.videoConsumer?.id === consumerId) {
-        this.videoConsumer?.resume();
-        this.logger.debug('Peer video track was resumed:', { peer: this });
+      const consumer = this.consumers.get(consumerId);
+      if (!consumer) {
         return;
       }
 
-      if (this.audioConsumer?.id === consumerId) {
-        this.audioConsumer?.resume();
-        this.logger.debug('Peer video track was resumed:', { peer: this });
-      }
-    });
-
-    this.observer.on(MEDIASOUP_EVENTS.consumerChangePreferredLayers, ({
-      spatialLayer, temporalLayer,
-    }: ChangePreferredLayersParams) => {
-      if (!this.videoConsumer) {
-        return;
-      }
-
-      this.videoConsumer.setCurrentSpatialLayer(spatialLayer);
-      this.videoConsumer.setCurrentTemporalLayer(temporalLayer);
-      this.logger.debug('Peer video track was changed preferred layers:', {
-        peer: this,
-        spatialLayer,
-        temporalLayer,
-      });
+      consumer.resume();
+      this.logger.debug('Peer video track was paused:', { peer: this });
     });
 
     // set outgoing connection quality for remote peer
@@ -556,8 +355,8 @@ class Peer {
         return;
       }
 
-      const consumer = payload.kind === 'audio' ? this.audioConsumer : this.videoConsumer;
-      if (consumer?.id !== payload.consumerId) {
+      const consumer = this.consumers.get(payload.consumerId);
+      if (!consumer) {
         return;
       }
 
@@ -565,22 +364,14 @@ class Peer {
       consumer.score = score;
       consumer.producerScore = producerScore;
 
-      const peerProducerScores = [];
-      if (this.audioConsumer) {
-        peerProducerScores.push(this.audioConsumer.producerScore);
-      }
-
-      if (this.videoConsumer) {
-        peerProducerScores.push(this.videoConsumer.producerScore);
-      }
-
+      const peerProducerScores: number[] = this.getAllConsumers().map((item) => item.producerScore);
       const minScore = Math.min(...peerProducerScores);
-      this.outgoingConnectionQuality = this.getConnectionQualityByScore(minScore);
+      this.outgoingConnectionQuality = Peer.getConnectionQualityByScore(minScore);
       this.emitConnectionQuality();
     });
 
     // set incoming connection quality for current peer
-    this.observer.on(MEDIASOUP_EVENTS.consumerScoreChanged, (payload: ConsumerScoreChangedPayload) => {
+    this.observer.on(MEDIASOUP_EVENTS.consumerScoreChanged, () => {
       if (!this.isMe) {
         return;
       }
@@ -588,14 +379,11 @@ class Peer {
       const allPeersLowQualityConsumersScores = [] as number[];
       // pick scores of low quality consumers (consumerScore < producerScore)
       this.engine.peers.forEach((peer) => {
-        const { videoConsumer, audioConsumer } = peer;
-        if (videoConsumer && videoConsumer?.score < videoConsumer?.producerScore) {
-          allPeersLowQualityConsumersScores.push(videoConsumer.score);
-        }
-
-        if (audioConsumer && audioConsumer?.score < audioConsumer?.producerScore) {
-          allPeersLowQualityConsumersScores.push(audioConsumer.score);
-        }
+        peer.getAllConsumers().forEach((item) => {
+          if (item.score < item.producerScore) {
+            allPeersLowQualityConsumersScores.push(item.score);
+          }
+        });
       }, []);
 
       if (allPeersLowQualityConsumersScores.length === 0) {
@@ -605,7 +393,7 @@ class Peer {
         // calculate average score of low quality consumers
         const scoresSum = allPeersLowQualityConsumersScores.map((score) => score).reduce((acc, curr) => acc + curr, 0);
         const averageConsumersScore = Math.floor(scoresSum / allPeersLowQualityConsumersScores.length);
-        this.incomingConnectionQuality = this.getConnectionQualityByScore(averageConsumersScore);
+        this.incomingConnectionQuality = Peer.getConnectionQualityByScore(averageConsumersScore);
       }
 
       this.emitConnectionQuality();
@@ -622,18 +410,18 @@ class Peer {
         return;
       }
 
-      let score = scores[0].score;
+      let { score } = scores[0];
 
       if (scores.length > 1) {
         // video with multiple encodings has personal score for each encoding
         const scoresSum = scores
-          .map(({ score }) => score)
+          .map(({ score: currentScore }) => currentScore)
           .reduce((acc, curr) => acc + curr, 0);
 
         score = Math.floor(scoresSum / payload.scores.length);
       }
 
-      this.outgoingConnectionQuality = this.getConnectionQualityByScore(score);
+      this.outgoingConnectionQuality = Peer.getConnectionQualityByScore(score);
       this.emitConnectionQuality();
     });
   }
@@ -647,18 +435,25 @@ class Peer {
     });
   }
 
-  private getConnectionQualityByScore(score: number): ConnectionQuality {
+  static getConnectionQualityByScore(score: number): ConnectionQuality {
     if (score < ScoreThreshold.BAD) {
       return ConnectionQuality.BAD;
     }
 
-    
     if (score < ScoreThreshold.MEDIUM) {
       return ConnectionQuality.MEDIUM;
     }
 
     return ConnectionQuality.GOOD;
   }
+
+  public getAllConsumers(): Consumer[] {
+    return Array.from(this.consumers.values());
+  }
+
+  public getAllProducers(): PeerProducer[] {
+    return Array.from(this.producers.values());
+  }
 }
 
 export default Peer;