@livedigital/client 3.0.7 → 3.0.9

package/dist/types/network.d.ts

@@ -1,5 +1,5 @@
-import { SocketIOEvents } from '../constants/events';
 import { Role } from './common';
+import { SocketIOEvents } from './socket';
 export declare type GetNodeRequest = {
     channelId: string;
     role: Role;

package/dist/types/socket.d.ts

@@ -0,0 +1,13 @@
+export declare enum SocketIOEvents {
+    Connect = "connect",
+    Connected = "connected",
+    ConnectError = "connect_error",
+    Reconnect = "reconnect",
+    Reconnecting = "reconnecting",
+    Reconnected = "reconnected",
+    ReconnectAttempt = "reconnect_attempt",
+    Disconnect = "disconnect",
+    Disconnected = "disconnected",
+    Error = "error",
+    State = "state"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.0.7",
+  "version": "3.0.9",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -23,7 +23,7 @@
     "url": "https://github.com/VLprojects/livedigital-sdk.git"
   },
   "scripts": {
-    "build": "rm -rf dist && rollup -c && tsc --importHelpers",
+    "build": "rm -rf dist && rollup -c && tsc --importHelpers && cp src/constants/* dist/constants/",
     "lint": "eslint ./src",
     "test": "NODE_ENV=test mocha --config test/utils/runners/mocha/.mocharc.js"
   },
@@ -46,7 +46,7 @@
     "axios": "^0.21.4",
     "bowser": "^2.11.0",
     "debug": "^4.3.4",
-    "mediasoup-client": "^3.6.50",
+    "mediasoup-client": "^3.6.103",
     "qs": "^6.11.0",
     "serialize-error": "^7.0.1",
     "socket.io-client": "^4.7.2",

package/src/constants/events.ts

@@ -53,15 +53,6 @@ export const PEER_EVENTS = {
   appDataUpdated: 'app-data-updated',
 };
 
-export enum SocketIOEvents {
-  Connected = 'connected',
-  Reconnecting = 'reconnecting',
-  Reconnected = 'reconnected',
-  Disconnected = 'disconnected',
-  Reconnect = 'reconnect',
-  Error = 'error',
-}
-
 export const MEDIASOUP_EVENTS = {
   newProducer: 'peer.newProducer',
   producerClose: 'producer.close',

package/src/engine/Peer.ts

@@ -417,6 +417,29 @@ class Peer {
     });
   }
 
+  reset() {
+    this.producers.clear();
+
+    this.tracks.forEach((x) => x.close());
+    this.tracks.clear();
+
+    const eventNames = [
+      MEDIASOUP_EVENTS.newProducer,
+      MEDIASOUP_EVENTS.producerClose,
+      MEDIASOUP_EVENTS.closeConsumer,
+      MEDIASOUP_EVENTS.pauseConsumer,
+      MEDIASOUP_EVENTS.resumeConsumer,
+      MEDIASOUP_EVENTS.consumerScoreChanged,
+      MEDIASOUP_EVENTS.consumerScoreChanged,
+      MEDIASOUP_EVENTS.producerScoreChanged,
+      MEDIASOUP_EVENTS.consumerChangePreferredLayers,
+      MEDIASOUP_EVENTS.producerSetMaxSpatialLayer,
+      CHANNEL_EVENTS.updatePeerAppData,
+    ];
+
+    eventNames.forEach((x) => this.observer.removeAllListeners(x));
+  }
+
   private emitConnectionQuality(): void {
     // after the initialization a new layer, or new producer, scores of producers and consumers drop for a short time
     setTimeout(() => {

package/src/engine/handlers/ChannelEventHandler.ts

@@ -72,6 +72,30 @@ class ChannelEventHandler {
       peer.observer.emit(CHANNEL_EVENTS.updatePeerAppData, appData);
     });
   }
+
+  private removeEventListeners() {
+    const { connection } = this.engine.network.socket;
+
+    if (!connection) {
+      return;
+    }
+
+    const eventNames = [
+      CHANNEL_EVENTS.channelEvent,
+      CHANNEL_EVENTS.channelJoin,
+      CHANNEL_EVENTS.channelLeave,
+      CHANNEL_EVENTS.activityConfirmationRequired,
+      CHANNEL_EVENTS.activityConfirmationExpired,
+      CHANNEL_EVENTS.activityConfirmationAcquired,
+      CHANNEL_EVENTS.updatePeerAppData,
+    ];
+
+    eventNames.forEach((x) => connection.removeAllListeners(x));
+  }
+
+  public reset() {
+    this.removeEventListeners();
+  }
 }
 
 export default ChannelEventHandler;

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -215,6 +215,37 @@ class MediaSoupEventHandler {
     });
   }
 
+  private removeEventListeners() {
+    const { connection } = this.engine.network.socket;
+
+    if (!connection) {
+      return;
+    }
+
+    const eventNames = [
+      MEDIASOUP_EVENTS.producerClose,
+      MEDIASOUP_EVENTS.newProducer,
+      MEDIASOUP_EVENTS.closeConsumer,
+      MEDIASOUP_EVENTS.resumeConsumer,
+      MEDIASOUP_EVENTS.pauseConsumer,
+      MEDIASOUP_EVENTS.consumerChangePreferredLayers,
+      MEDIASOUP_EVENTS.consumerScoreChanged,
+      MEDIASOUP_EVENTS.producerScoreChanged,
+      MEDIASOUP_EVENTS.producerRequestMaxSpatialLayer,
+      MEDIASOUP_EVENTS.producerSetMaxSpatialLayer,
+      MEDIASOUP_EVENTS.transportConnectionTimeout,
+      MEDIASOUP_EVENTS.producerPaused,
+      MEDIASOUP_EVENTS.producerResumed,
+      MEDIASOUP_EVENTS.producerForceClosed,
+    ];
+
+    eventNames.forEach((x) => connection.removeAllListeners(x));
+  }
+
+  public reset() {
+    this.removeEventListeners();
+  }
+
   private async handleProducerSetMaxSpatialLayer({
     producerId,
     spatialLayer,

package/src/engine/index.ts

@@ -24,8 +24,9 @@ import ChannelEventHandler from './handlers/ChannelEventHandler';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import Logger from './Logger';
 import {
-  CHANNEL_EVENTS, CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, SocketIOEvents,
+  CHANNEL_EVENTS, CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS,
 } from '../constants/events';
+import { SocketIOEvents } from '../types/socket';
 import {
   GetNodeRequest,
   JoinChannelRequest,
@@ -103,6 +104,8 @@ class Engine {
 
   private rejoinRequested = false;
 
+  private channelAudioObserverEventHandle: (data: string) => void;
+
   constructor(params: EngineParams) {
     const {
       clientEventEmitter,
@@ -144,6 +147,10 @@ class Engine {
       onLogMessage: params.onLogMessage,
     });
 
+    this.channelAudioObserverEventHandle = (data) => {
+      this.channelAudioObserverEventHandler.handle(data);
+    };
+
     this.logger = new Logger({
       logLevel: this.logLevel,
       namespace: 'Engine',
@@ -161,7 +168,6 @@ class Engine {
     });
 
     this.watchSocketState();
-    this.watchClientEvents();
   }
 
   private async initialize(): Promise<void> {
@@ -182,10 +188,13 @@ class Engine {
     } catch (error: unknown) {
       this.logger.error('initialize()', { error });
 
-      if (
-        (error instanceof MediasoupUnsupportedError && error.message === 'device not supported')
-        || (error instanceof Error && error.message === 'RTCPeerConnection is not defined')
-      ) {
+      const isDeviceNotSupported = error instanceof MediasoupUnsupportedError
+        && error.message === 'device not supported';
+
+      const isNoRTCPeerConnection = error instanceof Error
+        && error.message === 'RTCPeerConnection is not defined';
+
+      if (isDeviceNotSupported || isNoRTCPeerConnection) {
         throw new UnsupportedError('Device not supported', UnsupportedError.UNSUPPORTED_DEVICE_CODE);
       }
 
@@ -200,13 +209,25 @@ class Engine {
       this.app = undefined;
       this.channel = undefined;
       this.webRtcIssueDetector?.stopWatchingNewPeerConnections();
+
+      this.network.reset();
       this.network.socket.disconnect();
+
+      this.peersRepository.forEach((x) => x.reset());
       this.peersRepository.clear();
+
       await this.network.closeSendTransport();
       await this.network.closeReceiveTransport();
       await this.media.clearTracks();
+
+      this.audioObserver?.removeListener('message', this.channelAudioObserverEventHandle);
       this.audioObserver?.close();
 
+      this.channelEventsHandler.reset();
+      this.mediaSoupEventsHandler.reset();
+
+      this.removeClientEventEmitterListeners();
+
       this.logger.debug('release()', {
         socketId: this.mySocketId,
       });
@@ -216,8 +237,21 @@ class Engine {
     }
   }
 
+  private removeClientEventEmitterListeners(): void {
+    const eventNames = [
+      INTERNAL_CLIENT_EVENTS.trackProduced,
+      INTERNAL_CLIENT_EVENTS.trackUnproduced,
+      INTERNAL_CLIENT_EVENTS.trackPaused,
+      INTERNAL_CLIENT_EVENTS.trackResumed,
+      INTERNAL_CLIENT_EVENTS.trackClosed,
+      INTERNAL_CLIENT_EVENTS.trackReopened,
+    ];
+
+    eventNames.forEach((x) => this.clientEventEmitter.removeAllListeners(x));
+  }
+
   private watchSocketState(): void {
-    this.network.socket.observer.on('state', (evt: SocketObserverEvent) => {
+    this.network.socket.observer.on(SocketIOEvents.State, (evt: SocketObserverEvent) => {
       const { state, code, error } = evt;
       this.clientEventEmitter.emit(state, { code, error });
 
@@ -274,6 +308,7 @@ class Engine {
     try {
       this.logger.debug('join()', { params });
       this.isChannelJoining = true;
+      this.watchClientEvents();
       await this.connectToSocketServerWithRetry(params);
       await this.performJoin({ appData: params.appData });
     } catch (error) {
@@ -316,6 +351,7 @@ class Engine {
     }
 
     peer.tracks.forEach((track) => track.close());
+    peer.reset();
     this.peersRepository.delete(peerId);
   }
 
@@ -407,7 +443,7 @@ class Engine {
       tracks.forEach((track) => {
         track.mediaStreamTrack.addEventListener('ended', () => {
           track.unpublish();
-        });
+        }, { once: true });
 
         track.setStopTrackOnPause(Boolean(options?.stopTrackOnPause));
         if (track instanceof VideoTrack) {
@@ -521,7 +557,9 @@ class Engine {
     return new Promise((resolve, reject) => {
       const onSocketStateChange = async (data: SocketObserverEvent) => {
         const { error, state } = data;
-        const stopListening = () => this.network.socket.observer.removeListener('state', onSocketStateChange);
+        const stopListening = () => this.network.socket.observer
+          .removeListener(SocketIOEvents.State, onSocketStateChange);
+
         const isStateNotExpected = [SocketIOEvents.Disconnected, SocketIOEvents.Reconnecting].includes(state);
 
         if (error) {
@@ -542,7 +580,7 @@ class Engine {
         }
       };
 
-      this.network.socket.observer.on('state', onSocketStateChange);
+      this.network.socket.observer.on(SocketIOEvents.State, onSocketStateChange);
     });
   }
 
@@ -657,9 +695,7 @@ class Engine {
         channelId: this.channelId,
       });
 
-      audioObserver.on('message', (data) => {
-        this.channelAudioObserverEventHandler.handle(data);
-      });
+      audioObserver.on('message', this.channelAudioObserverEventHandle);
 
       this.audioObserver = audioObserver;
       this.logger.debug('Successfully create audio observer', logCtx);

package/src/engine/network/Socket.ts

@@ -1,6 +1,6 @@
 import { io, Socket } from 'socket.io-client';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { SocketIOEvents } from '../../constants/events';
+import { SocketIOEvents } from '../../types/socket';
 import { LogLevel, LogMessageHandler, SocketResponse } from '../../types/common';
 import Logger from '../Logger';
 
@@ -63,7 +63,7 @@ class SocketIO {
     this.connection = connection;
     this.serverUrl = serverUrl;
 
-    connection.on('connect', () => {
+    connection.on(SocketIOEvents.Connect, () => {
       const state = !this.reconnectingAttempt
         ? SocketIOEvents.Connected
         : SocketIOEvents.Reconnected;
@@ -71,39 +71,39 @@ class SocketIO {
       this.isConnected = true;
       this.setReconnectingAttempt(0);
 
-      this.logger.debug('connection.on(`connect`)', {
+      this.logger.debug(`connection.on('${SocketIOEvents.Connect}')`, {
         connectionId: connection.id,
       });
 
-      this.observer.safeEmit('state', { state });
+      this.observer.safeEmit(SocketIOEvents.State, { state });
     });
 
-    connection.on('connect_error', (error: unknown) => {
+    connection.on(SocketIOEvents.ConnectError, (error: unknown) => {
       this.connectionError = error as string;
-      this.logger.error('connection.on(`connect_error`)', { error });
-      this.observer.safeEmit('state', { state: SocketIOEvents.Error, error });
+      this.logger.error(`connection.on('${SocketIOEvents.ConnectError}')`, { error });
+      this.observer.safeEmit(SocketIOEvents.State, { state: SocketIOEvents.Error, error });
     });
 
-    connection.on('disconnect', ((reason: string) => {
+    connection.on(SocketIOEvents.Disconnect, ((reason: string) => {
       this.isConnected = false;
       this.setReconnectingAttempt(0);
       this.disconnectReason = reason;
-      this.logger.warn('connection.on(`disconnect`)', { reason });
-      this.observer.safeEmit('state', {
+      this.logger.warn(`connection.on('${SocketIOEvents.Disconnect}')`, { reason });
+      this.observer.safeEmit(SocketIOEvents.State, {
         state: SocketIOEvents.Disconnected,
         code: this.getDisconnectReasonCode(reason),
       });
     }));
 
-    connection.io.on('reconnect_attempt', (attempt: number) => {
+    connection.io.on(SocketIOEvents.ReconnectAttempt, (attempt: number) => {
       this.setReconnectingAttempt(attempt);
-      this.logger.warn('connection.on(`reconnect_attempt`)', { attempt });
-      this.observer.safeEmit('state', { state: SocketIOEvents.Reconnecting });
+      this.logger.warn(`connection.on('${SocketIOEvents.ReconnectAttempt}')`, { attempt });
+      this.observer.safeEmit(SocketIOEvents.State, { state: SocketIOEvents.Reconnecting });
     });
 
-    connection.io.on('reconnect', () => {
-      this.logger.debug('connection.on(`reconnect`)', { connectionId: connection.id });
-      this.observer.safeEmit('state', { state: SocketIOEvents.Reconnect });
+    connection.io.on(SocketIOEvents.Reconnect, () => {
+      this.logger.debug(`connection.on('${SocketIOEvents.Reconnect}')`, { connectionId: connection.id });
+      this.observer.safeEmit(SocketIOEvents.State, { state: SocketIOEvents.Reconnect });
     });
   }
 
@@ -112,6 +112,7 @@ class SocketIO {
       this.connection.offAny();
       this.connection.volatile.offAny();
       this.connection.disconnect();
+      this.connection.io.removeAllListeners();
       // we need to reset this counter in order not to get Reconnected event on retry
       this.setReconnectingAttempt(0);
     }

package/src/engine/network/index.ts

@@ -2,6 +2,7 @@ import {
   DtlsParameters,
   IceParameters,
   Transport,
+  TransportEvents,
   TransportOptions,
 } from 'mediasoup-client/lib/Transport';
 import { Device } from 'mediasoup-client';
@@ -64,6 +65,32 @@ class Network {
     });
   }
 
+  private removeEventListeners() {
+    const { sendTransport, receiveTransport } = this;
+
+    if (sendTransport) {
+      const eventNames: (keyof TransportEvents)[] = [
+        'connect',
+        'produce',
+        'connectionstatechange',
+      ];
+      eventNames.forEach((x) => sendTransport.removeAllListeners(x));
+    }
+
+    if (receiveTransport) {
+      const eventNames: (keyof TransportEvents)[] = [
+        'connect',
+        'produce',
+        'connectionstatechange',
+      ];
+      eventNames.forEach((x) => receiveTransport.removeAllListeners(x));
+    }
+  }
+
+  public reset() {
+    this.removeEventListeners();
+  }
+
   async closeRemoteProducer(producerId: string): Promise<void> {
     await this.socket.request(MEDIASOUP_EVENTS.producerClose, {
       peerId: this.socket.id,

package/src/types/network.ts

@@ -1,5 +1,5 @@
-import { SocketIOEvents } from '../constants/events';
 import { Role } from './common';
+import { SocketIOEvents } from './socket';
 
 export type GetNodeRequest = {
   channelId: string;

package/src/types/socket.ts

@@ -0,0 +1,16 @@
+// eslint-disable-next-line import/prefer-default-export
+export enum SocketIOEvents {
+  Connect = 'connect',
+  Connected = 'connected',
+  ConnectError = 'connect_error',
+
+  Reconnect = 'reconnect',
+  Reconnecting = 'reconnecting',
+  Reconnected = 'reconnected',
+  ReconnectAttempt = 'reconnect_attempt',
+
+  Disconnect = 'disconnect',
+  Disconnected = 'disconnected',
+  Error = 'error',
+  State = 'state',
+}