@livedigital/client 2.8.0 → 2.10.0

package/dist/types/engine.d.ts

@@ -0,0 +1,24 @@
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
+import System from '../engine/system';
+import Media from '../engine/media';
+import Network from '../engine/network';
+import Engine from '../engine';
+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 Logger from '../engine/Logger';
+export interface CreateIssueDetectorParams {
+    logger: Logger;
+}
+export interface CreateNetworkParams {
+    loadbalancer: LoadBalancerApiClientParams;
+}
+export interface EngineDependenciesFactory {
+    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.8.0",
+  "version": "2.10.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -0,0 +1,53 @@
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
+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 WebRTCIssueDetector from './wid/WebRTCIssueDetector';
+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(clientEventEmitter: EnhancedEventEmitter): System {
+    return new System({ clientEventEmitter });
+  }
+
+  createMedia(): Media {
+    return new Media();
+  }
+
+  createNetwork(params: CreateNetworkParams): Network {
+    const { loadbalancer } = params;
+    const socketClient = new SocketIO();
+    const loadBalancerApiClient = new LoadBalancerApiClient(loadbalancer);
+    return new Network({
+      socketClient,
+      loadBalancerApiClient,
+    });
+  }
+
+  createChannelEventHandler(engine: Engine): ChannelEventHandler {
+    return new ChannelEventHandler(engine);
+  }
+
+  createMediaSoupEventHandler(engine: Engine): MediaSoupEventHandler {
+    return new MediaSoupEventHandler(engine);
+  }
+
+  createIssueDetector(params: CreateIssueDetectorParams): WebRTCIssueDetector {
+    return new WebRTCIssueDetector({
+      onIssue: (issues: any[]) => {
+        issues.forEach((issue) => {
+          params.logger.warn('webRtcIssueDetector', issue);
+        });
+      },
+    });
+  }
+}
+/* eslint-enable class-methods-use-this */
+
+export default DefaultEngineDependenciesFactory;

package/src/engine/index.ts

@@ -15,7 +15,7 @@ import {
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
 import Peer from './Peer';
-import Network, { NetworkParams } from './network';
+import Network from './network';
 import Media from './media';
 import ChannelEventHandler from './handlers/ChannelEventHandler';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
@@ -29,11 +29,13 @@ import AudioTrack from './media/tracks/AudioTrack';
 import PeerTrack from './media/tracks/PeerTrack';
 import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import { retryAsync } from '../helpers/retry';
+import { CreateNetworkParams, EngineDependenciesFactory } from '../types/engine';
 
 type EngineParams = {
   clientEventEmitter: EnhancedEventEmitter,
-  network: NetworkParams,
+  network: CreateNetworkParams,
   onLogMessage?: LogMessageHandler;
+  dependenciesFactory: EngineDependenciesFactory;
 };
 
 class Engine {
@@ -61,7 +63,7 @@ class Engine {
 
   private isRoomJoining = false;
 
-  private logger: Logger;
+  private readonly logger: Logger;
 
   private webRtcIssueDetector: WebRTCIssueDetector;
 
@@ -69,22 +71,17 @@ class Engine {
     const {
       clientEventEmitter,
       network,
+      dependenciesFactory,
     } = params;
-    this.system = new System({ clientEventEmitter });
-    this.media = new Media();
-    this.network = new Network(network);
+    this.system = dependenciesFactory.createSystem(clientEventEmitter);
+    this.media = dependenciesFactory.createMedia();
+    this.network = dependenciesFactory.createNetwork(network);
     this.peersRepository = new Map<string, Peer>();
     this.clientEventEmitter = clientEventEmitter;
-    this.channelEventsHandler = new ChannelEventHandler(this);
-    this.mediaSoupEventsHandler = new MediaSoupEventHandler(this);
+    this.channelEventsHandler = dependenciesFactory.createChannelEventHandler(this);
+    this.mediaSoupEventsHandler = dependenciesFactory.createMediaSoupEventHandler(this);
     this.logger = new Logger('Engine', params.onLogMessage);
-    this.webRtcIssueDetector = new WebRTCIssueDetector({
-      onIssue: (issues: any[]) => {
-        issues.forEach((issue) => {
-          this.logger.warn('webRtcIssueDetector', issue);
-        });
-      },
-    });
+    this.webRtcIssueDetector = dependenciesFactory.createIssueDetector({ logger: this.logger });
 
     this.watchSocketState();
   }

package/src/engine/network/index.ts

@@ -7,12 +7,13 @@ import {
 import { Device } from 'mediasoup-client';
 import SocketIO from './Socket';
 import { ProduceParams } from '../../types/common';
-import LoadBalancerApiClient, { LoadBalancerApiClientParams } from './LoadBalancerClient';
+import LoadBalancerApiClient from './LoadBalancerClient';
 import { MEDIASOUP_EVENTS, MEDIASOUP_TRANSPORT_EVENTS } from '../../constants/events';
 import Logger from '../Logger';
 
 export type NetworkParams = {
-  loadbalancer: LoadBalancerApiClientParams,
+  socketClient: SocketIO;
+  loadBalancerApiClient: LoadBalancerApiClient;
 };
 
 class Network {
@@ -27,9 +28,9 @@ class Network {
   private readonly logger: Logger;
 
   constructor(params: NetworkParams) {
-    const { loadbalancer } = params;
-    this.socket = new SocketIO();
-    this.loadBalancerClient = new LoadBalancerApiClient(loadbalancer);
+    const { socketClient, loadBalancerApiClient } = params;
+    this.socket = socketClient;
+    this.loadBalancerClient = loadBalancerApiClient;
     this.logger = new Logger('Network');
   }
 

package/src/engine/wid/WebRTCIssueDetector.ts

@@ -32,6 +32,7 @@ class WebRTCIssueDetector {
       this.eventEmitter.on(EventType.Issue, params.onIssue);
     }
 
+    // Move instantiation from the constructor
     this.webrtcStats = new WebRTCStats({
       getStatsInterval: this.getStatsInterval,
     });

package/src/engine/wid/detectors/FramesDroppedIssueDetector.ts

@@ -52,7 +52,8 @@ class FramesDroppedIssueDetector implements IssueDetector {
           type: IssueType.CPU,
           reason: IssueReason.DecoderCPUThrottling,
           ssrc: streamStats.ssrc,
-          debug: `framesDropped: ${Math.round(framesDropped * 100)}`,
+          debug: `framesDropped: ${Math.round(framesDropped * 100)}`
+            + ` , deltaFramesDropped: ${deltaFramesDropped}, deltaFramesReceived: ${deltaFramesReceived}`,
         });
       }
     });

package/src/engine/wid/detectors/NetworkIssueDetector.ts

@@ -33,21 +33,30 @@ class NetworkIssueDetector implements IssueDetector {
 
     const rtpNetworkStats = inboundRTPStreamsStats.reduce((stats, currentStreamStats) => {
       const previousStreamStats = previousInboundStreamStats.find((stream) => stream.ssrc === currentStreamStats.ssrc);
+
       const lastJitterBufferDelay = previousStreamStats?.jitterBufferDelay || 0;
       const lastJitterBufferEmittedCount = previousStreamStats?.jitterBufferEmittedCount || 0;
       const delay = currentStreamStats.jitterBufferDelay - lastJitterBufferDelay;
       const emitted = currentStreamStats.jitterBufferEmittedCount - lastJitterBufferEmittedCount;
-      const latency = delay && emitted ? (1e3 * delay) / emitted : 0;
+      const jitterBufferDelayMs = delay && emitted ? (1e3 * delay) / emitted : 0;
 
       return {
-        maxLatency: latency > stats.maxLatency ? latency : stats.maxLatency,
+        sumJitter: stats.sumJitter + currentStreamStats.jitter,
+        sumJitterBufferDelayMs: stats.sumJitterBufferDelayMs + jitterBufferDelayMs,
         packetsLost: stats.packetsLost + currentStreamStats.packetsLost,
         lastPacketsLost: stats.lastPacketsLost + (previousStreamStats?.packetsLost || 0),
       };
-    }, { maxLatency: 0, packetsLost: 0, lastPacketsLost: 0 });
+    }, {
+      sumJitter: 0,
+      sumJitterBufferDelayMs: 0,
+      packetsLost: 0,
+      lastPacketsLost: 0,
+    });
 
     const rtt = (1e3 * data.connection.currentRoundTripTime) || 0;
-    const jitter = Math.round(rtt / 2 + rtpNetworkStats.maxLatency);
+    const { sumJitter, sumJitterBufferDelayMs } = rtpNetworkStats;
+    const avgJitter = sumJitter / inboundRTPStreamsStats.length;
+    const avgJitterBufferDelay = sumJitterBufferDelayMs / inboundRTPStreamsStats.length;
 
     const deltaPacketReceived = packetsReceived - lastPacketsReceived;
     const deltaPacketLost = rtpNetworkStats.packetsLost - rtpNetworkStats.lastPacketsLost;
@@ -57,19 +66,24 @@ class NetworkIssueDetector implements IssueDetector {
       : 0;
 
     const isHighPacketsLoss = packetsLoss > 5;
-    const isHighJitter = jitter >= 200;
-    const isHighRTT = rtt >= 200;
+    const isHighJitter = avgJitter >= 200;
+    const isHighRTT = rtt >= 250;
+    const isHighJitterBufferDelay = avgJitterBufferDelay > 500;
 
     const isNetworkIssue = (!isHighPacketsLoss && isHighJitter) || isHighJitter || isHighPacketsLoss;
     const isServerIssue = isHighRTT && !isHighJitter && !isHighPacketsLoss;
     const isNetworkMediaLatencyIssue = isHighPacketsLoss && isHighJitter;
+    const isNetworkMediaSyncIssue = isHighJitter && isHighJitterBufferDelay;
+
+    const debug = `packetLoss: ${packetsLoss}%, jitter: ${avgJitter}, rtt: ${rtt},`
+      + ` jitterBuffer: ${avgJitterBufferDelay}ms`;
 
     if (isNetworkIssue) {
       issues.push({
         type: IssueType.Network,
         reason: IssueReason.NetworkQuality,
         iceCandidate: data.connection.local.id,
-        debug: `packetLoss: ${packetsLoss}%, jitter: ${jitter}`,
+        debug,
       });
     }
 
@@ -78,7 +92,7 @@ class NetworkIssueDetector implements IssueDetector {
         type: IssueType.Server,
         reason: IssueReason.ServerIssue,
         iceCandidate: data.connection.remote.id,
-        debug: `packetLoss: ${packetsLoss}%,jitter: ${jitter}, rtt: ${rtt},`,
+        debug,
       });
     }
 
@@ -87,7 +101,16 @@ class NetworkIssueDetector implements IssueDetector {
         type: IssueType.Network,
         reason: IssueReason.NetworkMediaLatency,
         iceCandidate: data.connection.local.id,
-        debug: `packetLoss: ${packetsLoss}%, jitter: ${jitter}`,
+        debug,
+      });
+    }
+
+    if (isNetworkMediaSyncIssue) {
+      issues.push({
+        type: IssueType.Network,
+        reason: IssueReason.NetworkMediaSyncFailure,
+        iceCandidate: data.connection.local.id,
+        debug,
       });
     }
 

package/src/index.ts

@@ -4,18 +4,20 @@ import {
   CreateMicrophoneAudioTrackOptions,
   CreateScreenMediaOptions,
   JoinChannelParams,
+  LogMessageHandler,
   Role,
   Track,
-  LogMessageHandler,
 } from './types/common';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
 import Engine from './engine';
 import Peer from './engine/Peer';
 import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
+import DefaultEngineDependenciesFactory from './engine/DefaultEngineDependenciesFactory';
 
 type ClientParams = {
+  observer?: EnhancedEventEmitter;
   network?: {
-    loadbalancer?: LoadBalancerApiClientParams,
+    loadbalancer?: LoadBalancerApiClientParams;
   },
   onLogMessage?: LogMessageHandler;
 };
@@ -23,11 +25,14 @@ type ClientParams = {
 class Client {
   private readonly engine: Engine;
 
-  private readonly _observer = new EnhancedEventEmitter();
+  private readonly _observer: EnhancedEventEmitter;
 
   constructor(params: ClientParams) {
-    const { network, onLogMessage } = params;
+    const { observer, network, onLogMessage } = params;
+    this._observer = observer ?? new EnhancedEventEmitter();
+    const dependenciesFactory = new DefaultEngineDependenciesFactory();
     this.engine = new Engine({
+      dependenciesFactory,
       clientEventEmitter: this.observer,
       network: {
         loadbalancer: {

package/src/types/engine.ts

@@ -0,0 +1,27 @@
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
+import System from '../engine/system';
+import Media from '../engine/media';
+import Network from '../engine/network';
+import Engine from '../engine';
+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 Logger from '../engine/Logger';
+
+export interface CreateIssueDetectorParams {
+  logger: Logger;
+}
+
+export interface CreateNetworkParams {
+  loadbalancer: LoadBalancerApiClientParams;
+}
+
+export interface EngineDependenciesFactory {
+  createSystem: (clientEventEmitter: EnhancedEventEmitter) => System;
+  createMedia: () => Media;
+  createNetwork: (networkParams: CreateNetworkParams) => Network;
+  createChannelEventHandler: (engine: Engine) => ChannelEventHandler;
+  createMediaSoupEventHandler: (engine: Engine) => MediaSoupEventHandler;
+  createIssueDetector: (params: CreateIssueDetectorParams) => WebRTCIssueDetector;
+}