@livedigital/client 2.27.0 → 2.28.0

package/dist/types/common.d.ts

@@ -133,6 +133,7 @@ export declare type AudioEncoderConfig = EncoderConfig & {
     enableFec?: boolean;
 };
 export declare type CreateTrackOptions = {
+    stopTrackOnPause?: boolean;
     encoderConfig?: EncoderConfig;
     deviceId?: string;
 };
@@ -154,6 +155,7 @@ export declare type CreateScreenAudioTrackOptions = CreateMicrophoneAudioTrackOp
     encoderConfig?: AudioEncoderConfig;
 };
 export declare type CreateScreenMediaOptions = {
+    stopTrackOnPause?: boolean;
     video: CreateScreenVideoTrackOptions;
     audio: CreateScreenAudioTrackOptions;
 };

package/dist/types/engine.d.ts

@@ -7,7 +7,7 @@ import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { Logger, LogLevel } from './common';
+import { Logger, LogLevel, LogMessageHandler } from './common';
 export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
 export declare type NetworkScoresUpdatedHandler = (networks: NetworkScores) => void;
 export interface CreateIssueDetectorParams {
@@ -20,20 +20,31 @@ export interface CreateMediaParams {
     logLevel: LogLevel;
     engine: Engine;
     clientEventEmitter: EnhancedEventEmitter;
+    onLogMessage?: LogMessageHandler;
 }
 export interface CreateNetworkParams {
     logLevel: LogLevel;
     loadbalancer: LoadBalancerApiClientParams;
+    onLogMessage?: LogMessageHandler;
 }
 export interface CreateSystemParams {
     logLevel: LogLevel;
     clientEventEmitter: EnhancedEventEmitter;
+    onLogMessage?: LogMessageHandler;
+}
+export interface CreateMediaSoupEventHandlerParams {
+    engine: Engine;
+    onLogMessage?: LogMessageHandler;
+}
+export interface CreateChannelEventHandlerParams {
+    engine: Engine;
+    onLogMessage?: LogMessageHandler;
 }
 export interface EngineDependenciesFactory {
     createSystem: (params: CreateSystemParams) => System;
     createMedia: (params: CreateMediaParams) => Media;
     createNetwork: (params: CreateNetworkParams) => Network;
-    createChannelEventHandler: (engine: Engine) => ChannelEventHandler;
-    createMediaSoupEventHandler: (engine: Engine) => MediaSoupEventHandler;
+    createChannelEventHandler: (params: CreateChannelEventHandlerParams) => ChannelEventHandler;
+    createMediaSoupEventHandler: (params: CreateMediaSoupEventHandlerParams) => MediaSoupEventHandler;
     createIssueDetector: (params: CreateIssueDetectorParams) => WebRTCIssueDetector;
 }

package/package.json

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

package/src/constants/events.ts

@@ -21,6 +21,8 @@ export const INTERNAL_CLIENT_EVENTS = {
   trackUnproduced: 'track-unproduced',
   trackPaused: 'track-paused',
   trackResumed: 'track-resumed',
+  trackClosed: 'track-closed',
+  trackReopened: 'track-reopened',
 };
 
 export const PEER_EVENTS = {

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -17,11 +17,11 @@ import Network from './network';
 import System from './system';
 import Media from './media';
 import ChannelEventHandler from './handlers/ChannelEventHandler';
-import Engine from './index';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import {
   CreateIssueDetectorParams,
   CreateMediaParams,
+  CreateMediaSoupEventHandlerParams,
   CreateNetworkParams,
   CreateSystemParams,
   EngineDependenciesFactory,
@@ -40,9 +40,10 @@ class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
   }
 
   createNetwork(params: CreateNetworkParams): Network {
-    const { loadbalancer, logLevel } = params;
+    const { loadbalancer, logLevel, onLogMessage } = params;
     const socketClient = new SocketIO({
       logLevel,
+      onLogMessage,
     });
 
     const loadBalancerApiClient = new LoadBalancerApiClient(loadbalancer);
@@ -50,15 +51,16 @@ class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
       logLevel,
       socketClient,
       loadBalancerApiClient,
+      onLogMessage,
     });
   }
 
-  createChannelEventHandler(engine: Engine): ChannelEventHandler {
-    return new ChannelEventHandler(engine);
+  createChannelEventHandler(params: CreateMediaSoupEventHandlerParams): ChannelEventHandler {
+    return new ChannelEventHandler(params);
   }
 
-  createMediaSoupEventHandler(engine: Engine): MediaSoupEventHandler {
-    return new MediaSoupEventHandler(engine);
+  createMediaSoupEventHandler(params: CreateMediaSoupEventHandlerParams): MediaSoupEventHandler {
+    return new MediaSoupEventHandler(params);
   }
 
   createIssueDetector(params: CreateIssueDetectorParams): WebRTCIssueDetector {

package/src/engine/handlers/ChannelEventHandler.ts

@@ -1,4 +1,9 @@
-import { ChannelEvent, PeerResponse, UpdatePeerAppDataPayload } from '../../types/common';
+import {
+  ChannelEvent,
+  LogMessageHandler,
+  PeerResponse,
+  UpdatePeerAppDataPayload,
+} from '../../types/common';
 import Engine from '../index';
 import { CHANNEL_EVENTS, CLIENT_EVENTS } from '../../constants/events';
 import Logger from '../Logger';
@@ -8,11 +13,13 @@ class ChannelEventHandler {
 
   private readonly logger: Logger;
 
-  constructor(engine: Engine) {
+  constructor(params: { engine: Engine, onLogMessage?: LogMessageHandler }) {
+    const { engine, onLogMessage } = params;
     this.engine = engine;
     this.logger = new Logger({
       logLevel: engine.logLevel,
       namespace: 'ChannelEvents',
+      onLogMessage,
     });
   }
 

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -2,6 +2,7 @@ import { AwaitQueue } from 'awaitqueue';
 import {
   ChangePreferredLayersParams,
   ConsumerScoreChangedPayload,
+  LogMessageHandler,
   ProducerData,
   ProducerRequestMaxSpatialLayer,
   ProducerScoreChangedPayload,
@@ -20,11 +21,13 @@ class MediaSoupEventHandler {
 
   private readonly queue = new AwaitQueue();
 
-  constructor(engine: Engine) {
+  constructor(params: { engine: Engine, onLogMessage?: LogMessageHandler }) {
+    const { engine, onLogMessage } = params;
     this.engine = engine;
     this.logger = new Logger({
       logLevel: engine.logLevel,
       namespace: 'MediasoupEvents',
+      onLogMessage,
     });
   }
 

package/src/engine/index.ts

@@ -87,20 +87,30 @@ class Engine {
     this.system = dependenciesFactory.createSystem({
       logLevel: this.logLevel,
       clientEventEmitter,
+      onLogMessage: params.onLogMessage,
     });
     this.media = dependenciesFactory.createMedia({
       logLevel: this.logLevel,
       engine: this,
       clientEventEmitter,
+      onLogMessage: params.onLogMessage,
     });
     this.network = dependenciesFactory.createNetwork({
       logLevel: this.logLevel,
       loadbalancer: network.loadbalancer,
+      onLogMessage: params.onLogMessage,
     });
     this.peersRepository = new Map<string, Peer>();
     this.clientEventEmitter = clientEventEmitter;
-    this.channelEventsHandler = dependenciesFactory.createChannelEventHandler(this);
-    this.mediaSoupEventsHandler = dependenciesFactory.createMediaSoupEventHandler(this);
+    this.channelEventsHandler = dependenciesFactory.createChannelEventHandler({
+      engine: this,
+      onLogMessage: params.onLogMessage,
+    });
+    this.mediaSoupEventsHandler = dependenciesFactory.createMediaSoupEventHandler({
+      engine: this,
+      onLogMessage: params.onLogMessage,
+    });
+
     this.logger = new Logger({
       logLevel: this.logLevel,
       namespace: 'Engine',
@@ -162,7 +172,6 @@ class Engine {
       this.clientEventEmitter.emit(state, { code });
 
       if (state === SocketIOEvents.Reconnected) {
-        this.network.socket.disconnect();
         this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
       }
     });
@@ -255,6 +264,7 @@ class Engine {
         video: trackParams.videoTrackOptions,
       });
 
+      track.setStopTrackOnPause(Boolean(options?.stopTrackOnPause));
       if (track instanceof VideoTrack) {
         track.setLabel(TrackLabel.Camera);
         track.setEncoderConfig(trackParams.encoderConfig);
@@ -279,6 +289,7 @@ class Engine {
       });
 
       track.setLabel(TrackLabel.Microphone);
+      track.setStopTrackOnPause(Boolean(options?.stopTrackOnPause));
       if (options?.encoderConfig) {
         track.setEncoderConfig(options.encoderConfig);
       }
@@ -304,6 +315,7 @@ class Engine {
           track.unpublish();
         });
 
+        track.setStopTrackOnPause(Boolean(options?.stopTrackOnPause));
         if (track instanceof VideoTrack) {
           track.setLabel(TrackLabel.ScreenVideo);
           track.setEncoderConfig(videoTrackParams.encoderConfig);
@@ -468,10 +480,20 @@ class Engine {
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackPaused, (track: Track) => {
       const peerTrack = this.myPeer?.tracks.get(track.getLabel());
-      peerTrack?.close();
+      peerTrack?.pause();
     });
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackResumed, (track: Track) => {
+      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
+      peerTrack?.resume();
+    });
+
+    this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackClosed, (track: Track) => {
+      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
+      peerTrack?.close();
+    });
+
+    this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackReopened, (track: Track) => {
       this.createSelfPeerTrack(track);
     });
   }

package/src/engine/media/index.ts

@@ -39,6 +39,7 @@ class Media {
     this.#logger = new Logger({
       namespace: 'Media',
       logLevel: params.logLevel,
+      onLogMessage: params.onLogMessage,
     });
     this.#engine = params.engine;
     this.#clientEventEmitter = params.clientEventEmitter;

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

@@ -54,6 +54,8 @@ class BaseTrack {
 
   readonly #mediaStreamTrackManager: MediaStreamTrackManager;
 
+  #stopTrackOnPause = true;
+
   constructor(params: BaseTrackConstructorParams) {
     const {
       mediaStreamTrack, logLevel, engine, clientEventEmitter, constraints, mediaStreamTrackManager,
@@ -119,6 +121,14 @@ class BaseTrack {
     this.producer = producer;
   }
 
+  setStopTrackOnPause(value: boolean): void {
+    if (this.isPublished) {
+      return;
+    }
+
+    this.#stopTrackOnPause = value;
+  }
+
   getProducer(): Producer | undefined {
     return this.producer;
   }
@@ -375,9 +385,15 @@ class BaseTrack {
       await this.cancelProducerCheckState();
       await this.pauseRemoteProducer(this.producer.id);
       this.producer.pause();
-      this.#mediaStreamTrack.stop();
-      this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackPaused, this);
       this.logger.debug('pause()', { track: this });
+
+      if (this.#stopTrackOnPause) {
+        this.#mediaStreamTrack.stop();
+        this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackClosed, this);
+        return;
+      }
+
+      this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackPaused, this);
     } catch (error) {
       this.logger.error('pause()', { error, track: this });
       throw new Error('Can`t pause track');
@@ -391,16 +407,16 @@ class BaseTrack {
     }
 
     try {
-      const track = await this.#mediaStreamTrackManager.createMediaStreamTrack({
-        label: this.label,
-        constraints: this.#constraints,
-      });
-      this.#mediaStreamTrack = track;
-      await this.producer.replaceTrack({ track });
-      await this.resumeRemoteProducer(this.producer.id);
-      this.producer.resume();
-      this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackResumed, this);
       this.logger.debug('resume()', { track: this });
+      if (this.#stopTrackOnPause) {
+        await this.reopenMediaStreamTrack();
+        await this.resumeProducer();
+        this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackReopened, this);
+        return;
+      }
+
+      await this.resumeProducer();
+      this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackResumed, this);
     } catch (error) {
       this.logger.error('resume()', { error, track: this });
       throw new Error('Can`t resume track');
@@ -439,6 +455,26 @@ class BaseTrack {
     }
   }
 
+  private async resumeProducer(): Promise<void> {
+    if (!this.producer) {
+      this.logger.debug('resumeProducer()', { message: 'Track not produced yet', track: this });
+      return;
+    }
+
+    await this.resumeRemoteProducer(this.producer.id);
+    this.producer.resume();
+  }
+
+  private async reopenMediaStreamTrack(): Promise<void> {
+    const track = await this.#mediaStreamTrackManager.createMediaStreamTrack({
+      label: this.label,
+      constraints: this.#constraints,
+    });
+
+    this.#mediaStreamTrack = track;
+    await this.producer?.replaceTrack({ track });
+  }
+
   private getOutboundRTPStreamStats(): Promise<RTCOutboundRtpStreamStats> {
     return new Promise((resolve, reject) => {
       const getRTCStatsReport = async (attempt = 0) => {

package/src/engine/network/Socket.ts

@@ -1,11 +1,12 @@
 import { io, Socket } from 'socket.io-client';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { SocketIOEvents } from '../../constants/events';
-import { LogLevel, SocketResponse } from '../../types/common';
+import { LogLevel, LogMessageHandler, SocketResponse } from '../../types/common';
 import Logger from '../Logger';
 
 export type SocketIOConstructorParams = {
   logLevel: LogLevel,
+  onLogMessage?: LogMessageHandler,
 };
 
 class SocketIO {
@@ -37,6 +38,7 @@ class SocketIO {
     this.logger = new Logger({
       namespace: 'Socket',
       logLevel: params.logLevel,
+      onLogMessage: params.onLogMessage,
     });
   }
 

package/src/engine/network/index.ts

@@ -8,7 +8,13 @@ import { Device } from 'mediasoup-client';
 import { Consumer } from 'mediasoup-client/lib/Consumer';
 import SocketIO from './Socket';
 import {
-  CreateConsumerPayload, LogLevel, ProduceParams, RemoteConsumerOptions, SocketResponse, UpdatePeerAppDataPayload,
+  CreateConsumerPayload,
+  LogLevel,
+  LogMessageHandler,
+  ProduceParams,
+  RemoteConsumerOptions,
+  SocketResponse,
+  UpdatePeerAppDataPayload,
 } from '../../types/common';
 import LoadBalancerApiClient from './LoadBalancerClient';
 import { CHANNEL_EVENTS, MEDIASOUP_EVENTS, MEDIASOUP_TRANSPORT_EVENTS } from '../../constants/events';
@@ -18,6 +24,7 @@ export type NetworkParams = {
   socketClient: SocketIO;
   logLevel: LogLevel,
   loadBalancerApiClient: LoadBalancerApiClient;
+  onLogMessage?: LogMessageHandler;
 };
 
 class Network {
@@ -32,12 +39,13 @@ class Network {
   private readonly logger: Logger;
 
   constructor(params: NetworkParams) {
-    const { socketClient, loadBalancerApiClient } = params;
+    const { socketClient, loadBalancerApiClient, onLogMessage } = params;
     this.socket = socketClient;
     this.loadBalancerClient = loadBalancerApiClient;
     this.logger = new Logger({
       namespace: 'Network',
       logLevel: params.logLevel,
+      onLogMessage,
     });
   }
 

package/src/engine/system/index.ts

@@ -20,11 +20,12 @@ class System {
   private readonly logger: Logger;
 
   constructor(params: CreateSystemParams) {
-    const { clientEventEmitter, logLevel } = params;
+    const { clientEventEmitter, logLevel, onLogMessage } = params;
     this.clientEventEmitter = clientEventEmitter;
     this.logger = new Logger({
       namespace: 'System',
       logLevel,
+      onLogMessage,
     });
 
     this.deviceChangeHandler = this.deviceChangeHandler.bind(this);

package/src/types/common.ts

@@ -159,6 +159,7 @@ export type AudioEncoderConfig = EncoderConfig & {
 };
 
 export type CreateTrackOptions = {
+  stopTrackOnPause?: boolean,
   encoderConfig?: EncoderConfig,
   deviceId?: string,
 };
@@ -186,6 +187,7 @@ export type CreateScreenAudioTrackOptions = CreateMicrophoneAudioTrackOptions &
 };
 
 export type CreateScreenMediaOptions = {
+  stopTrackOnPause?: boolean,
   video: CreateScreenVideoTrackOptions,
   audio: CreateScreenAudioTrackOptions,
 };

package/src/types/engine.ts

@@ -7,7 +7,7 @@ import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { Logger, LogLevel } from './common';
+import { Logger, LogLevel, LogMessageHandler } from './common';
 
 export type IssuesHandler = (issues: IssueDetectorResult) => void;
 
@@ -24,23 +24,36 @@ export interface CreateMediaParams {
   logLevel: LogLevel;
   engine: Engine;
   clientEventEmitter: EnhancedEventEmitter;
+  onLogMessage?: LogMessageHandler;
 }
 
 export interface CreateNetworkParams {
   logLevel: LogLevel;
   loadbalancer: LoadBalancerApiClientParams;
+  onLogMessage?: LogMessageHandler;
 }
 
 export interface CreateSystemParams {
   logLevel: LogLevel;
-  clientEventEmitter: EnhancedEventEmitter
+  clientEventEmitter: EnhancedEventEmitter;
+  onLogMessage?: LogMessageHandler;
+}
+
+export interface CreateMediaSoupEventHandlerParams {
+  engine: Engine;
+  onLogMessage?: LogMessageHandler;
+}
+
+export interface CreateChannelEventHandlerParams {
+  engine: Engine;
+  onLogMessage?: LogMessageHandler;
 }
 
 export interface EngineDependenciesFactory {
   createSystem: (params: CreateSystemParams) => System;
   createMedia: (params: CreateMediaParams) => Media;
   createNetwork: (params: CreateNetworkParams) => Network;
-  createChannelEventHandler: (engine: Engine) => ChannelEventHandler;
-  createMediaSoupEventHandler: (engine: Engine) => MediaSoupEventHandler;
+  createChannelEventHandler: (params: CreateChannelEventHandlerParams) => ChannelEventHandler;
+  createMediaSoupEventHandler: (params: CreateMediaSoupEventHandlerParams) => MediaSoupEventHandler;
   createIssueDetector: (params: CreateIssueDetectorParams) => WebRTCIssueDetector;
 }