@livedigital/client 2.17.0 → 2.18.0-webrtc-issue-events.2

package/dist/types/common.d.ts

@@ -1,5 +1,7 @@
 import { MediaKind, RtpEncodingParameters, RtpParameters } from 'mediasoup-client/lib/types';
 import { ConsumerOptions } from 'mediasoup-client/lib/Consumer';
+import { RtpCapabilities } from 'mediasoup-client/src/RtpParameters';
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
 import AudioTrack from '../engine/media/tracks/AudioTrack';
 import VideoTrack from '../engine/media/tracks/VideoTrack';
 export declare type SocketResponse = {
@@ -13,6 +15,12 @@ export declare type ProduceParams = {
     rtpParameters: RtpParameters;
     appData: Record<string, unknown>;
 };
+export declare type TrackProduceParams = {
+    encodings?: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+    preferredCodec?: string;
+    transformParams?: TrackTransformParams;
+};
 export declare type TrackTransformParams = {
     width?: number;
     height?: number;
@@ -212,3 +220,13 @@ export declare type TransportConnectionTimeoutPayload = {
     direction: 'receive' | 'send';
     timeout: number;
 };
+export declare type ExtendedRTCInboundRtpStreamStats = RTCInboundRtpStreamStats & {
+    decoderImplementation?: string;
+};
+export declare type CreateConsumerPayload = {
+    producerId: string;
+    rtpCapabilities: RtpCapabilities;
+    appId?: string;
+    channelId?: string;
+    producerPeerId: string;
+};

package/dist/types/engine.d.ts

@@ -12,9 +12,12 @@ import { LogLevel } from './common';
 export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
 export interface CreateIssueDetectorParams {
     onIssues?: IssuesHandler;
+    ignoreSSRCList?: number[];
 }
 export interface CreateMediaParams {
     logLevel: LogLevel;
+    engine: Engine;
+    clientEventEmitter: EnhancedEventEmitter;
 }
 export interface CreateNetworkParams {
     logLevel: LogLevel;

package/package.json

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

package/src/constants/common.ts

@@ -11,3 +11,6 @@ export const LogLevels = {
   Info: LOG_LEVEL_INFO,
   Debug: LOG_LEVEL_DEBUG,
 };
+
+export const CONSUMER_CHECK_STATE_TIMEOUT = 5000;
+export const PRODUCER_CHECK_STATE_TIMEOUT = 3000;

package/src/constants/events.ts

@@ -12,6 +12,14 @@ export const CLIENT_EVENTS = {
   channelRejoinRequired: 'channel-rejoin-required',
   devicesListUpdated: 'devices-list-updated',
   transportConnectionTimeout: 'transport-connection-timeout',
+  trackPublishingFailed: 'track-publishing-failed',
+};
+
+export const INTERNAL_CLIENT_EVENTS = {
+  trackProduced: 'track-produced',
+  trackUnproduced: 'track-unproduced',
+  trackPaused: 'track-paused',
+  trackResumed: 'track-resumed',
 };
 
 export const PEER_EVENTS = {
@@ -22,6 +30,7 @@ export const PEER_EVENTS = {
   trackEnd: 'track-end',
   trackPaused: 'track-paused',
   trackResumed: 'track-resumed',
+  trackFailed: 'track-failed',
 };
 
 export enum SocketIOEvents {

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -50,6 +50,7 @@ class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
   createIssueDetector(params: CreateIssueDetectorParams): WebRTCIssueDetector {
     return new WebRTCIssueDetector({
       onIssues: params.onIssues,
+      ignoreSSRCList: params.ignoreSSRCList,
     });
   }
 }

package/src/engine/Peer.ts

@@ -8,7 +8,6 @@ import {
   ChangePreferredLayersPayload,
   Role,
   ProducerSetMaxSpatialLayer,
-  RemoteConsumerOptions,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Engine from './index';
@@ -114,61 +113,44 @@ class Peer {
   }
 
   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;
-    }
-
-    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.createConsumer(producer);
-  }
+    try {
+      const producer = this.producers.get(producerId);
+      if (!producer) {
+        this.logger.warn('subscribe()', { message: 'Peer does not have a producer', peer: this, producerId });
+        return;
+      }
 
-  private async createConsumer(producer: PeerProducer): Promise<void> {
-    const transport = this.engine.network.receiveTransport;
-    if (!transport) {
-      this.logger.error('createConsumer()', 'missing receiveTransport');
-      throw new Error('Client not initialized');
-    }
+      const peerConsumer = this.getAllConsumers().find((item) => item.producerId === producerId);
+      if (peerConsumer) {
+        this.logger.debug('subscribe()', { message: 'Already subscribed to producer', peer: this, producerId });
+        return;
+      }
 
-    try {
-      const remoteConsumer = await this.engine.network.socket.request(MEDIASOUP_EVENTS.createConsumer, {
+      const { isProducerPaused, consumer } = await this.engine.network.createConsumer({
         producerId: producer.id,
-        transportId: transport.id,
         rtpCapabilities: this.engine.media.mediasoupDevice.rtpCapabilities,
-        appData: {
-          peerId: this.engine.mySocketId,
-          appId: this.engine.appId,
-          channelId: this.engine.channelId,
-        },
         producerPeerId: this.id,
-      }) as RemoteConsumerOptions;
-
-      const consumer = await transport.consume(remoteConsumer);
-      if (!remoteConsumer.producerPaused) {
-        await this.engine.network.socket.request(MEDIASOUP_EVENTS.resumeConsumer, { consumerId: consumer.id });
-      }
+        appId: this.engine.appId,
+        channelId: this.engine.channelId,
+      });
 
-      this.logger.debug(`Subscribed for ${producer.kind}`, { peer: this });
       const track = new PeerTrack({
         mediaStreamTrack: consumer.track,
         label: producer.label,
-        consumer: new PeerConsumer({
-          consumer,
-          logLevel: this.engine.logLevel,
-        }),
+        consumer: new PeerConsumer({ consumer, logLevel: this.engine.logLevel }),
         engine: this.engine,
-        isPaused: remoteConsumer.producerPaused,
+        isPaused: true,
         peerEventEmitter: this.observer,
       });
+
+      if (!isProducerPaused) {
+        await track.resume();
+      }
+
       this.tracks.set(track.label, track);
+      this.logger.debug(`Subscribed for ${producer.kind}`, { peer: this });
     } catch (error) {
-      this.logger.error('createConsumer()', producer, error);
+      this.logger.error('subscribe()', { producerId, error });
       throw new Error('Error subscribe media');
     }
   }

package/src/engine/PeerConsumer.ts

@@ -1,7 +1,12 @@
 import { parseScalabilityMode } from 'mediasoup-client';
 import { MediaKind, RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
 import { Consumer as MediasoupConsumer } from 'mediasoup-client/lib/types';
-import { ConsumerData, LogLevel, SpatialLayerParams } from '../types/common';
+import {
+  ConsumerData,
+  ExtendedRTCInboundRtpStreamStats,
+  LogLevel,
+  SpatialLayerParams,
+} from '../types/common';
 import Logger from './Logger';
 
 export type PeerConsumerConstructorParams = {
@@ -161,6 +166,33 @@ class PeerConsumer {
   setCurrentMaxSpatialLayer(spatialLayer: number): void {
     this.currentMaxSpatialLayer = spatialLayer;
   }
+
+  async getInboundRTPStreamStats(): Promise<ExtendedRTCInboundRtpStreamStats> {
+    return new Promise((resolve, reject) => {
+      const getRTCStatsReport = async (attempt = 0) => {
+        try {
+          const rtcStatsReport = await this.consumer.getStats();
+          const inboundRTPStreamStats: ExtendedRTCInboundRtpStreamStats = Array.from(rtcStatsReport.values())
+            .find((stat) => stat.type === 'inbound-rtp');
+          if (!inboundRTPStreamStats && attempt < 5) {
+            setTimeout(() => getRTCStatsReport(attempt + 1), 150);
+            return;
+          }
+
+          if (attempt >= 5 && !inboundRTPStreamStats) {
+            reject(new Error('InboundRTPStreamStat not exist'));
+          }
+
+          resolve(inboundRTPStreamStats);
+        } catch (error) {
+          reject(new Error('Can not get RTCStatsReport'));
+          this.logger.warn('getInboundRTPStreamStats()', { error });
+        }
+      };
+
+      getRTCStatsReport();
+    });
+  }
 }
 
 export default PeerConsumer;

package/src/engine/index.ts

@@ -21,11 +21,10 @@ import ChannelEventHandler from './handlers/ChannelEventHandler';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import Logger from './Logger';
 import {
-  CHANNEL_EVENTS, CLIENT_EVENTS, MEDIASOUP_EVENTS, SocketIOEvents,
+  CHANNEL_EVENTS, CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, SocketIOEvents,
 } from '../constants/events';
 import { GetNodeRequest } from '../types/network';
 import VideoTrack from './media/tracks/VideoTrack';
-import AudioTrack from './media/tracks/AudioTrack';
 import PeerTrack from './media/tracks/PeerTrack';
 import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import { retryAsync } from '../helpers/retry';
@@ -89,6 +88,8 @@ class Engine {
     });
     this.media = dependenciesFactory.createMedia({
       logLevel: this.logLevel,
+      engine: this,
+      clientEventEmitter,
     });
     this.network = dependenciesFactory.createNetwork({
       logLevel: this.logLevel,
@@ -106,9 +107,11 @@ class Engine {
 
     this.webRtcIssueDetector = dependenciesFactory.createIssueDetector({
       onIssues: params.onIssues,
+      ignoreSSRCList: [1234], // mediasoup-client probator
     });
 
     this.watchSocketState();
+    this.watchClientEvents();
   }
 
   private async initialize(): Promise<void> {
@@ -137,7 +140,7 @@ class Engine {
       this.webRtcIssueDetector.resetWatchedPeerConnectionsList();
       this.network.socket.disconnect();
       this.peersRepository.clear();
-      await this.unpublish();
+      await this.unpublishAllTracks();
       await this.network.closeSendTransport();
       await this.network.closeReceiveTransport();
 
@@ -148,14 +151,6 @@ class Engine {
     }
   }
 
-  private async pauseRemoteProducer(producerId: string): Promise<SocketResponse> {
-    return this.network.socket.request(MEDIASOUP_EVENTS.pauseProducer, { producerId });
-  }
-
-  private async resumeRemoteProducer(producerId: string): Promise<SocketResponse> {
-    return this.network.socket.request(MEDIASOUP_EVENTS.resumeProducer, { producerId });
-  }
-
   private watchSocketState(): void {
     this.network.socket.observer.on('state', (evt: { state: SocketIOEvents, code?: string }) => {
       const { state, code } = evt;
@@ -221,44 +216,6 @@ class Engine {
     this.peersRepository.delete(peerId);
   }
 
-  public async pause(track: Track): Promise<void> {
-    const producer = track.getProducer();
-    if (!producer) {
-      this.logger.warn('pause()', { message: 'Track is not published', kind: track.kind });
-      return;
-    }
-
-    try {
-      await this.pauseRemoteProducer(producer.id);
-      producer.pause();
-      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
-      peerTrack?.pause();
-      this.logger.debug('pause()', { kind: track.kind });
-    } catch (error) {
-      this.logger.error('pause()', { error, kind: track.kind });
-      throw new Error('Can`t pause track');
-    }
-  }
-
-  public async resume(track: Track): Promise<void> {
-    const producer = track.getProducer();
-    if (!producer) {
-      this.logger.warn('resume()', { message: 'Track is not published' });
-      return;
-    }
-
-    try {
-      await this.resumeRemoteProducer(producer.id);
-      producer.resume();
-      this.logger.debug('resume()', { kind: track.kind });
-      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
-      peerTrack?.resume();
-    } catch (error) {
-      this.logger.error('resume()', { error, kind: track.kind });
-      throw new Error('Can`t resume track');
-    }
-  }
-
   async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track> {
     const trackParams = Media.getCameraVideoTrackParams(options);
     try {
@@ -313,7 +270,7 @@ class Engine {
 
       tracks.forEach((track) => {
         track.mediaStreamTrack.addEventListener('ended', () => {
-          this.unpublish(track);
+          track.unpublish();
         });
 
         if (track instanceof VideoTrack) {
@@ -339,115 +296,6 @@ class Engine {
     }
   }
 
-  public async publish(tracks: Track | Track[]): Promise<void> {
-    if (!this.cahPublish) {
-      this.logger.error('publish()', { message: 'Not enough access to publish' });
-      throw new Error('Not enough access to publish');
-    }
-
-    const tracksToPublish = Array.isArray(tracks) ? tracks : [tracks];
-    const actions = tracksToPublish.map(async (track) => {
-      const encodings = 'getEncodings' in track
-        ? track.getEncodings()
-        : undefined;
-
-      const codecOptions = 'getCodecOptions' in track
-        ? track.getCodecOptions()
-        : undefined;
-
-      const maxSpatialLayer = 0;
-      const appData = {
-        peerId: this.mySocketId,
-        label: track.getLabel(),
-        trackTransformParams: {},
-        maxSpatialLayer: 0,
-      };
-
-      if (track instanceof VideoTrack) {
-        appData.maxSpatialLayer = maxSpatialLayer;
-        appData.trackTransformParams = track.transformParams;
-      }
-
-      const producer = await this.network.sendTransport?.produce({
-        track: track.mediaStreamTrack,
-        encodings,
-        codecOptions,
-        codec: this.media.getTrackCodec(track),
-        stopTracks: true,
-        disableTrackOnPause: true,
-        zeroRtpOnPause: true,
-        appData,
-      });
-
-      if (!producer) {
-        return;
-      }
-
-      track.setProducer(producer);
-
-      if (track instanceof VideoTrack) {
-        await track.setMaxSpatialLayer(maxSpatialLayer);
-        await this.network.socket.request(MEDIASOUP_EVENTS.producerSetMaxSpatialLayer, {
-          producerId: track.getProducer()?.id,
-          maxSpatialLayer,
-        });
-      }
-
-      if (track instanceof AudioTrack) {
-        await track.setPriority('high');
-      }
-
-      const myPeer = this.peersRepository.get(<string> this.mySocketId);
-      if (!myPeer) {
-        return;
-      }
-
-      const peerTrack = new PeerTrack({
-        mediaStreamTrack: track.mediaStreamTrack,
-        label: track.getLabel(),
-        engine: this,
-        isPaused: producer.paused,
-        peerEventEmitter: myPeer.observer,
-      });
-      myPeer.tracks.set(peerTrack.label, peerTrack);
-      this.logger.debug('publish()', { track, encodings, codecOptions });
-    });
-
-    try {
-      await Promise.all(actions);
-    } catch (error) {
-      this.logger.error('publish()', { error });
-    }
-  }
-
-  public async unpublish(tracks?: Track | Track[]): Promise<void> {
-    let tracksToUnpublish: Track[];
-    if (!tracks) {
-      tracksToUnpublish = this.media.getAllTracks();
-    } else {
-      tracksToUnpublish = Array.isArray(tracks) ? tracks : [tracks];
-    }
-
-    const actions = tracksToUnpublish.map(async (track) => {
-      const producer = track.getProducer();
-      if (producer && this.network.socket.connection?.connected) {
-        await this.network.closeRemoteProducer(producer.id);
-      }
-
-      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
-      peerTrack?.close();
-
-      await this.media.deleteTrack(track);
-      this.logger.debug('unpublish()', { track });
-    });
-
-    try {
-      await Promise.all(actions);
-    } catch (error) {
-      this.logger.error('unpublish()', { error });
-    }
-  }
-
   deleteTrack(tracks: Track): void {
     return this.media.deleteTrack(tracks);
   }
@@ -568,6 +416,45 @@ class Engine {
   private get myPeer(): Peer | undefined {
     return this.peers.find((peer) => peer.isMe);
   }
+
+  private async unpublishAllTracks(): Promise<void> {
+    await Promise.all(this.media.getAllTracks().map((track) => track.unpublish()));
+  }
+
+  private watchClientEvents(): void {
+    this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackProduced, (track: Track) => {
+      const myPeer = this.peersRepository.get(<string> this.mySocketId);
+      if (!myPeer) {
+        return;
+      }
+
+      const peerTrack = new PeerTrack({
+        mediaStreamTrack: track.mediaStreamTrack,
+        label: track.getLabel(),
+        engine: this,
+        isPaused: track.isPaused,
+        peerEventEmitter: myPeer.observer,
+      });
+
+      myPeer.tracks.set(peerTrack.label, peerTrack);
+    });
+
+    this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackUnproduced, (track: Track) => {
+      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
+      peerTrack?.close();
+      this.media.deleteTrack(track);
+    });
+
+    this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackPaused, (track: Track) => {
+      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
+      peerTrack?.pause();
+    });
+
+    this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackResumed, (track: Track) => {
+      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
+      peerTrack?.resume();
+    });
+  }
 }
 
 export default Engine;

package/src/engine/media/index.ts

@@ -9,6 +9,8 @@ import Logger from '../Logger';
 import { VIDEO_CONSTRAINS } from '../../constants/videoConstrains';
 import { SCREEN_SHARING_SIMULCAST_ENCODINGS, WEBCAM_SIMULCAST_ENCODINGS } from '../../constants/simulcastEncodings';
 import { CreateMediaParams } from '../../types/engine';
+import Engine from '../index';
+import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 
 class Media {
   public isDeviceLoaded = false;
@@ -17,9 +19,13 @@ class Media {
 
   private tracks: Map<string, Track> = new Map();
 
-  #logger: Logger;
+  readonly #logger: Logger;
 
-  #logLevel: LogLevel;
+  readonly #logLevel: LogLevel;
+
+  readonly #engine: Engine;
+
+  readonly #clientEventEmitter: EnhancedEventEmitter;
 
   constructor(params: CreateMediaParams) {
     this.#logLevel = params.logLevel;
@@ -27,6 +33,8 @@ class Media {
       namespace: 'Media',
       logLevel: params.logLevel,
     });
+    this.#engine = params.engine;
+    this.#clientEventEmitter = params.clientEventEmitter;
   }
 
   get mediasoupDevice(): Device {
@@ -57,10 +65,14 @@ class Media {
   private createTracks(stream: MediaStream): Track[] {
     const mediaStreamTracks = stream.getTracks();
     return mediaStreamTracks.map((mediaStreamTrack) => {
-      const track = mediaStreamTrack.kind === 'audio'
-        ? new AudioTrack({ mediaStreamTrack, logLevel: this.#logLevel })
-        : new VideoTrack({ mediaStreamTrack, logLevel: this.#logLevel });
-
+      const params = {
+        mediaStreamTrack,
+        logLevel: this.#logLevel,
+        engine: this.#engine,
+        clientEventEmitter: this.#clientEventEmitter,
+      };
+
+      const track = mediaStreamTrack.kind === 'audio' ? new AudioTrack(params) : new VideoTrack(params);
       this.tracks.set(track.id, track);
       this.#logger.debug('createTrack() track created', {
         streamId: stream.id,

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

@@ -2,6 +2,7 @@ import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
 import { AudioCodec, AudioEncoderConfig } from '../../../types/common';
 import BaseTrack from './BaseTrack';
 import TrackWithCodecOptions from './TrackWithCodecOptions';
+import { INTERNAL_CLIENT_EVENTS } from '../../../constants/events';
 
 class AudioTrack extends BaseTrack implements TrackWithCodecOptions {
   getEncoderConfig(): AudioEncoderConfig {
@@ -22,6 +23,15 @@ class AudioTrack extends BaseTrack implements TrackWithCodecOptions {
 
     return 'opus';
   }
+
+  async publish(): Promise<void> {
+    await this.produce({
+      preferredCodec: this.getPreferredCodec(),
+      codecOptions: this.getCodecOptions(),
+    });
+
+    this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackProduced, this);
+  }
 }
 
 export default AudioTrack;