@livedigital/client 2.12.0-add-onissue-callback.3 → 2.12.0

package/dist/types/common.d.ts

@@ -1,4 +1,5 @@
 import { MediaKind, RtpEncodingParameters, RtpParameters } from 'mediasoup-client/lib/types';
+import { ConsumerOptions } from 'mediasoup-client/lib/Consumer';
 import AudioTrack from '../engine/media/tracks/AudioTrack';
 import VideoTrack from '../engine/media/tracks/VideoTrack';
 export declare type SocketResponse = {
@@ -153,17 +154,6 @@ export declare enum TrackLabel {
     ScreenAudio = "screen-audio",
     Unknown = "unknown"
 }
-export declare type StartTrackPayload = {
-    producerId: string;
-    consumerId?: string;
-    track: MediaStreamTrack;
-    label: TrackLabel;
-};
-export declare type EndTrackPayload = {
-    producerId: string;
-    kind: MediaKind;
-    label: TrackLabel;
-};
 export declare type PayloadOfPublishedMedia = {
     producerId: string;
     kind: MediaKind;
@@ -209,5 +199,7 @@ export declare type TransformParams = {
     width?: number;
     height?: number;
 };
+export declare type RemoteConsumerOptions = ConsumerOptions & {
+    producerPaused: boolean;
+};
 export declare type LogMessageHandler = (msg: any, ...meta: any) => void;
-export declare type LogLevel = 3 | 4 | 6 | 7;

package/dist/types/engine.d.ts

@@ -7,27 +7,17 @@ import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { IssueDetectorResult } from '../engine/wid/types';
-import { LogLevel } from './common';
-export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
+import Logger from '../engine/Logger';
 export interface CreateIssueDetectorParams {
-    onIssues?: IssuesHandler;
-}
-export interface CreateMediaParams {
-    logLevel: LogLevel;
+    logger: Logger;
 }
 export interface CreateNetworkParams {
-    logLevel: LogLevel;
     loadbalancer: LoadBalancerApiClientParams;
 }
-export interface CreateSystemParams {
-    logLevel: LogLevel;
-    clientEventEmitter: EnhancedEventEmitter;
-}
 export interface EngineDependenciesFactory {
-    createSystem: (params: CreateSystemParams) => System;
-    createMedia: (params: CreateMediaParams) => Media;
-    createNetwork: (params: CreateNetworkParams) => Network;
+    createSystem: (clientEventEmitter: EnhancedEventEmitter) => System;
+    createMedia: () => Media;
+    createNetwork: (networkParams: CreateNetworkParams) => Network;
     createChannelEventHandler: (engine: Engine) => ChannelEventHandler;
     createMediaSoupEventHandler: (engine: Engine) => MediaSoupEventHandler;
     createIssueDetector: (params: CreateIssueDetectorParams) => WebRTCIssueDetector;

package/package.json

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

package/src/constants/events.ts

@@ -19,6 +19,8 @@ export const PEER_EVENTS = {
   connectionQualityChanged: 'connection-quality-changed',
   trackStart: 'track-start',
   trackEnd: 'track-end',
+  trackPaused: 'track-paused',
+  trackResumed: 'track-resumed',
 };
 
 export enum SocketIOEvents {

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -1,3 +1,4 @@
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Network from './network';
 import System from './system';
 import Media from './media';
@@ -5,35 +6,25 @@ import ChannelEventHandler from './handlers/ChannelEventHandler';
 import Engine from './index';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
-import {
-  CreateIssueDetectorParams,
-  CreateMediaParams,
-  CreateNetworkParams,
-  CreateSystemParams,
-  EngineDependenciesFactory,
-} from '../types/engine';
+import { CreateIssueDetectorParams, CreateNetworkParams, EngineDependenciesFactory } from '../types/engine';
 import SocketIO from './network/Socket';
 import LoadBalancerApiClient from './network/LoadBalancerClient';
 
 /* eslint-disable class-methods-use-this */
 class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
-  createSystem(params: CreateSystemParams): System {
-    return new System(params);
+  createSystem(clientEventEmitter: EnhancedEventEmitter): System {
+    return new System({ clientEventEmitter });
   }
 
-  createMedia(params: CreateMediaParams): Media {
-    return new Media(params);
+  createMedia(): Media {
+    return new Media();
   }
 
   createNetwork(params: CreateNetworkParams): Network {
-    const { loadbalancer, logLevel } = params;
-    const socketClient = new SocketIO({
-      logLevel,
-    });
-
+    const { loadbalancer } = params;
+    const socketClient = new SocketIO();
     const loadBalancerApiClient = new LoadBalancerApiClient(loadbalancer);
     return new Network({
-      logLevel,
       socketClient,
       loadBalancerApiClient,
     });
@@ -49,7 +40,11 @@ class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
 
   createIssueDetector(params: CreateIssueDetectorParams): WebRTCIssueDetector {
     return new WebRTCIssueDetector({
-      onIssues: params.onIssues,
+      onIssue: (issues: any[]) => {
+        issues.forEach((issue) => {
+          params.logger.warn('webRtcIssueDetector', issue);
+        });
+      },
     });
   }
 }

package/src/engine/Logger.ts

@@ -1,48 +1,35 @@
 import debug from 'debug';
-import { LogLevels } from '../constants/common';
-import { LogLevel, LogMessageHandler } from '../types/common';
+import { LogMessageHandler } from '../types/common';
 
 const APP_NAME = 'LiveDigital';
 
-export type LoggerConstructorParams = {
-  namespace: string,
-  logLevel: LogLevel,
-  onLogMessage?: LogMessageHandler,
-};
-
 class Logger {
   private readonly _debug: debug.Debugger;
 
-  private readonly _info: debug.Debugger;
-
   private readonly _warn: debug.Debugger;
 
   private readonly _error: debug.Debugger;
 
-  #namespace: string;
-
-  #logLevel: LogLevel;
-
-  #onLogMessage: LogMessageHandler;
-
-  constructor(params: LoggerConstructorParams) {
-    const { logLevel, namespace, onLogMessage } = params;
-    this.#namespace = namespace;
-    this.#logLevel = logLevel;
-
-    this._debug = debug(APP_NAME).extend('debug').extend(this.#namespace);
-    this._info = debug(APP_NAME).extend('info').extend(this.#namespace);
-    this._warn = debug(APP_NAME).extend('warn').extend(this.#namespace);
-    this._error = debug(APP_NAME).extend('error').extend(this.#namespace);
+  private readonly onLogMessage: LogMessageHandler;
+
+  constructor(prefix?: string, onLogMessage?: LogMessageHandler) {
+    if (prefix) {
+      this._debug = debug(`${APP_NAME}:${prefix}`);
+      this._warn = debug(`${APP_NAME}:WARN:${prefix}`);
+      this._error = debug(`${APP_NAME}:ERROR:${prefix}`);
+    } else {
+      this._debug = debug(APP_NAME);
+      this._warn = debug(`${APP_NAME}:WARN`);
+      this._error = debug(`${APP_NAME}:ERROR`);
+    }
 
     /* eslint-disable no-console */
     this._debug.log = console.info.bind(console);
-    this._info.log = console.info.bind(console);
     this._warn.log = console.warn.bind(console);
     this._error.log = console.error.bind(console);
     /* eslint-enable no-console */
 
-    this.#onLogMessage = (msg: any, ...meta: any[]) => {
+    this.onLogMessage = (msg: any, ...meta: any[]) => {
       if (typeof onLogMessage === 'function') {
         onLogMessage(msg, ...meta);
       }
@@ -51,30 +38,17 @@ class Logger {
 
   debug(msg: any, ...meta: any[]): void {
     this._debug(msg, ...meta);
-    if (this.#logLevel >= LogLevels.Debug) {
-      this.#onLogMessage(msg, ...meta);
-    }
-  }
-
-  info(msg: any, ...meta: any[]): void {
-    this._debug(msg, ...meta);
-    if (this.#logLevel >= LogLevels.Info) {
-      this.#onLogMessage(msg, ...meta);
-    }
+    this.onLogMessage(msg, ...meta);
   }
 
   warn(msg: any, ...meta: any[]): void {
     this._warn(msg, ...meta);
-    if (this.#logLevel >= LogLevels.Warn) {
-      this.#onLogMessage(msg, ...meta);
-    }
+    this.onLogMessage(msg, ...meta);
   }
 
   error(msg: any, ...meta: any[]): void {
     this._error(msg, ...meta);
-    if (this.#logLevel >= LogLevels.Error) {
-      this.#onLogMessage(msg, ...meta);
-    }
+    this.onLogMessage(msg, ...meta);
   }
 }
 

package/src/engine/Peer.ts

@@ -1,14 +1,14 @@
-import { ConsumerOptions } from 'mediasoup-client/lib/Consumer';
 import {
   ConsumerScoreChangedPayload,
   ProducerData,
   ProducerScoreChangedPayload,
   ConnectionQuality,
-  EndTrackPayload,
   PayloadOfPublishedMedia,
   PayloadOfUnpublishedMedia,
   ChangePreferredLayersPayload,
   Role,
+  ProducerSetMaxSpatialLayer,
+  RemoteConsumerOptions,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Engine from './index';
@@ -89,10 +89,7 @@ class Peer {
     this.uid = uid;
     this.role = role;
     this.engine = engine;
-    this.logger = new Logger({
-      logLevel: engine.logLevel,
-      namespace: 'Peer',
-    });
+    this.logger = new Logger('Peer');
     producers.forEach(this.handleNewProducer.bind(this));
     this.handlePeerEvents();
   }
@@ -147,23 +144,23 @@ class Peer {
           channelId: this.engine.channelId,
         },
         producerPeerId: this.id,
-      }) as ConsumerOptions;
+      }) as RemoteConsumerOptions;
 
       const consumer = await transport.consume(remoteConsumer);
-      await this.engine.network.socket.request(MEDIASOUP_EVENTS.resumeConsumer, { consumerId: consumer.id });
+      if (!remoteConsumer.producerPaused) {
+        await this.engine.network.socket.request(MEDIASOUP_EVENTS.resumeConsumer, { consumerId: consumer.id });
+      }
 
       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),
         engine: this.engine,
+        isPaused: remoteConsumer.producerPaused,
+        peerEventEmitter: this.observer,
       });
       this.tracks.set(track.label, track);
-      this.observer.safeEmit(PEER_EVENTS.trackStart, track);
     } catch (error) {
       this.logger.error('createConsumer()', producer, error);
       throw new Error('Error subscribe media');
@@ -199,39 +196,32 @@ class Peer {
     });
 
     this.observer.on(MEDIASOUP_EVENTS.closeConsumer, (consumerId) => {
-      const consumer = this.getConsumerById(consumerId);
-      if (!consumer) {
+      const track = this.getTrackByConsumerId(consumerId);
+      if (!track) {
         return;
       }
 
-      consumer.close();
-      this.tracks.delete(consumer.appData.producerData.label);
-      this.observer.safeEmit(PEER_EVENTS.trackEnd, {
-        producerId: consumer.producerId,
-        kind: consumer.kind,
-        label: consumer.appData.producerData.label,
-      } as EndTrackPayload);
+      track.close();
+      this.tracks.delete(track.label);
       this.logger.debug('Peer video track was ended:', { peer: this });
     });
 
-    this.observer.on(MEDIASOUP_EVENTS.pauseConsumer, (consumerId) => {
-      const consumer = this.getConsumerById(consumerId);
-      if (!consumer) {
+    this.observer.on(MEDIASOUP_EVENTS.pauseConsumer, async (consumerId) => {
+      const track = this.getTrackByConsumerId(consumerId);
+      if (!track) {
         return;
       }
 
-      consumer.pause();
-      this.logger.debug('Peer video track was paused:', { peer: this });
+      await track.pause();
     });
 
-    this.observer.on(MEDIASOUP_EVENTS.resumeConsumer, (consumerId) => {
-      const consumer = this.getConsumerById(consumerId);
-      if (!consumer) {
+    this.observer.on(MEDIASOUP_EVENTS.resumeConsumer, async (consumerId) => {
+      const track = this.getTrackByConsumerId(consumerId);
+      if (!track) {
         return;
       }
 
-      consumer.resume();
-      this.logger.debug('Peer video track was paused:', { peer: this });
+      await track.resume();
     });
 
     // set outgoing connection quality for remote peer
@@ -333,6 +323,46 @@ class Peer {
         this.logger.debug('consumerChangePreferredLayers()', { consumer, ...payload });
       }
     });
+
+    this.observer.on(MEDIASOUP_EVENTS.producerSetMaxSpatialLayer, async (payload: ProducerSetMaxSpatialLayer) => {
+      const { producerId, spatialLayer } = payload;
+      const consumer = this.getConsumerByProducerId(producerId);
+      if (!consumer) {
+        this.logger.debug('producerSetMaxSpatialLayer()', {
+          message: 'Consumer for producer not created, ignore MaxSpatialLayer change',
+        });
+
+        return;
+      }
+
+      consumer.setCurrentMaxSpatialLayer(spatialLayer);
+      this.logger.debug('producerSetMaxSpatialLayer()', {
+        producerId,
+        consumerId: consumer.id,
+        spatialLayer,
+      });
+
+      if (consumer.requestedSpatialLayer !== spatialLayer) {
+        this.logger.debug('producerSetMaxSpatialLayer()', {
+          message: 'No need to request new preferred layer',
+          currentMaxSpatialLayer: spatialLayer,
+          requestedMaxSpatialLayer: consumer.requestedSpatialLayer,
+        });
+
+        return;
+      }
+
+      await this.engine.network.socket.request(MEDIASOUP_EVENTS.consumerChangePreferredLayers, {
+        consumerId: consumer.id,
+        spatialLayer,
+      });
+
+      this.logger.debug('requestVideoPreferredLayers()', {
+        producerId,
+        consumerId: consumer.id,
+        spatialLayer,
+      });
+    });
   }
 
   private emitConnectionQuality(): void {
@@ -371,17 +401,17 @@ class Peer {
       .filter((item): item is PeerConsumer => !!item);
   }
 
-  public getAllProducers(): PeerProducer[] {
-    return Array.from(this.producers.values());
-  }
-
-  public getConsumerByProducerId(producerId: string): PeerConsumer | undefined {
+  private getConsumerByProducerId(producerId: string): PeerConsumer | undefined {
     return this.getAllConsumers().find((consumer) => consumer.producerId === producerId);
   }
 
-  public getConsumerById(id: string): PeerConsumer | undefined {
+  private getConsumerById(id: string): PeerConsumer | undefined {
     return this.getAllConsumers().find((consumer) => consumer.id === id);
   }
+
+  private getTrackByConsumerId(id: string): PeerTrack | undefined {
+    return Array.from(this.tracks.values()).find((track) => track.consumerId === id);
+  }
 }
 
 export default Peer;

package/src/engine/PeerConsumer.ts

@@ -1,14 +1,9 @@
 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, SpatialLayerParams } from '../types/common';
 import Logger from './Logger';
 
-export type PeerConsumerConstructorParams = {
-  consumer: MediasoupConsumer,
-  logLevel: LogLevel,
-};
-
 class PeerConsumer {
   public score = 10;
 
@@ -42,17 +37,13 @@ class PeerConsumer {
 
   private readonly logger: Logger;
 
-  constructor(params: PeerConsumerConstructorParams) {
-    const { logLevel, consumer } = params;
+  constructor(consumer: MediasoupConsumer) {
     this.id = consumer.id;
     this.kind = consumer.kind as MediaKind;
     this.producerId = consumer.producerId;
     this.appData = consumer.appData as ConsumerData;
     this.consumer = consumer;
-    this.logger = new Logger({
-      logLevel,
-      namespace: 'PeerConsumer',
-    });
+    this.logger = new Logger('PeerConsumer');
     this.currentMaxSpatialLayer = this.appData.producerData.maxSpatialLayer;
     this.parseScalabilityMode();
     this.setSpatialLayersParams();

package/src/engine/handlers/ChannelEventHandler.ts

@@ -10,10 +10,7 @@ class ChannelEventHandler {
 
   constructor(engine: Engine) {
     this.engine = engine;
-    this.logger = new Logger({
-      logLevel: engine.logLevel,
-      namespace: 'ChannelEvents',
-    });
+    this.logger = new Logger('ChannelEvents');
   }
 
   public subscribeToEvents(): void {

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -17,10 +17,7 @@ class MediaSoupEventHandler {
 
   constructor(engine: Engine) {
     this.engine = engine;
-    this.logger = new Logger({
-      logLevel: engine.logLevel,
-      namespace: 'MediasoupEvents',
-    });
+    this.logger = new Logger('MediasoupEvents');
   }
 
   public subscribeToEvents(): void {
@@ -156,39 +153,7 @@ class MediaSoupEventHandler {
         return;
       }
 
-      const consumer = peer.getConsumerByProducerId(producerId);
-      if (!consumer) {
-        this.logger.warn('producerSetMaxSpatialLayer()', { message: 'Consumer not found' });
-        return;
-      }
-
-      consumer.setCurrentMaxSpatialLayer(spatialLayer);
-      this.logger.debug('producerSetMaxSpatialLayer()', {
-        producerId,
-        consumerId: consumer.id,
-        spatialLayer,
-      });
-
-      if (consumer.requestedSpatialLayer !== spatialLayer) {
-        this.logger.debug('producerSetMaxSpatialLayer()', {
-          message: 'No need to request new preferred layer',
-          currentMaxSpatialLayer: spatialLayer,
-          requestedMaxSpatialLayer: consumer.requestedSpatialLayer,
-        });
-
-        return;
-      }
-
-      await this.engine.network.socket.request(MEDIASOUP_EVENTS.consumerChangePreferredLayers, {
-        consumerId: consumer.id,
-        spatialLayer,
-      });
-
-      this.logger.debug('requestVideoPreferredLayers()', {
-        producerId,
-        consumerId: consumer.id,
-        spatialLayer,
-      });
+      peer.observer.safeEmit(MEDIASOUP_EVENTS.producerSetMaxSpatialLayer, { peerId, producerId, spatialLayer });
     });
   }
 }