@livedigital/client 1.1.5 → 1.4.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "1.1.5",
+  "version": "1.4.1",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -45,22 +45,21 @@
     "mediasoup-client": "^3.6.42",
     "qs": "^6.9.6",
     "serialize-error": "^7.0.1",
-    "socket.io-client": "^4.2.0"
+    "socket.io-client": "^4.3.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^19.0.0",
     "@rollup/plugin-json": "^4.1.0",
     "@rollup/plugin-node-resolve": "^13.0.0",
     "@rollup/plugin-replace": "^3.0.0",
-    "@types/node": "^12.0.0",
-    "@types/qs": "^6.9.5",
-    "@types/socket.io-client": "^1.4.34",
-    "@typescript-eslint/eslint-plugin": "^4.23.0",
     "@semantic-release/commit-analyzer": "^9.0.1",
     "@semantic-release/git": "^10.0.0",
     "@semantic-release/github": "^8.0.1",
     "@semantic-release/npm": "^8.0.0",
     "@semantic-release/release-notes-generator": "^10.0.2",
+    "@types/node": "^12.0.0",
+    "@types/qs": "^6.9.5",
+    "@typescript-eslint/eslint-plugin": "^4.23.0",
     "dotenv": "^10.0.0",
     "eslint": "^7.23.0",
     "eslint-config-airbnb-typescript": "^12.3.1",

package/src/constants/events.ts

@@ -7,8 +7,10 @@ export const CHANNEL_EVENTS = {
 
 export const CLIENT_EVENTS = {
   channelEvent: 'channel-event',
-  channelJoin: 'peer-joined',
+  peerJoined: 'peer-joined',
+  peerLeft: 'peer-left',
   channelLeave: 'peer-left',
+  channelRejoinRequired: 'channel-rejoin-required',
 };
 
 export const PEER_EVENTS = {

package/src/engine/Peer.ts

@@ -47,7 +47,7 @@ class Peer {
 
   public uid?: string;
 
-  public appData = {};
+  public appData: Record<string, unknown>;
 
   private videoProducer?: ProducerData;
 
@@ -75,7 +75,8 @@ class Peer {
     videoConsumer,
     audioConsumer,
     engine,
-    appData = {},
+    appData,
+    uid,
   }: PeerConstructor) {
     this.id = id;
     this.channelId = channelId;
@@ -84,7 +85,8 @@ class Peer {
     this.isVirtual = isVirtual;
     this.originChannelId = originChannelId;
     this.originPeerId = originPeerId;
-    this.appData = appData;
+    this.appData = appData || {};
+    this.uid = uid;
     this.engine = engine;
     this.videoConsumer = videoConsumer;
     this.audioConsumer = audioConsumer;
@@ -159,11 +161,13 @@ class Peer {
 
   public async subscribeVideo(): Promise<void> {
     if (!this.videoProducer) {
-      throw new Error('Video producer not found');
+      this.logger.warn('subscribeVideo()', { message: 'This peer has no published video', peer: this });
+      return;
     }
 
     if (this.videoConsumer) {
-      throw new Error('Already subscribed');
+      this.logger.warn('subscribeVideo()', { message: 'Already subscribed this peer\'s video', peer: this });
+      return;
     }
 
     await this.createConsumer(this.videoProducer);
@@ -171,11 +175,13 @@ class Peer {
 
   public async subscribeAudio(): Promise<void> {
     if (!this.audioProducer) {
-      throw new Error('Audio producer not found');
+      this.logger.warn('subscribeAudio()', { message: 'This peer has no published audio', peer: this });
+      return;
     }
 
     if (this.audioConsumer) {
-      throw new Error('Already subscribed');
+      this.logger.warn('subscribeAudio()', { message: 'Already subscribed this peer\'s audio', peer: this });
+      return;
     }
 
     await this.createConsumer(this.audioProducer);
@@ -183,6 +189,7 @@ class Peer {
 
   public async unSubscribeVideo(): Promise<void> {
     if (!this.videoConsumer) {
+      this.logger.warn('unSubscribeVideo()', { message: 'This peer has no subscribed video', peer: this });
       return;
     }
 
@@ -193,6 +200,7 @@ class Peer {
 
   public async unSubscribeAudio(): Promise<void> {
     if (!this.audioConsumer) {
+      this.logger.warn('unSubscribeAudio()', { message: 'This peer has no subscribed audio', peer: this });
       return;
     }
 
@@ -236,52 +244,79 @@ class Peer {
   }
 
   public async pauseVideo(): Promise<void> {
-    if (!this.videoConsumer || this.videoConsumer.paused) {
+    if (!this.videoConsumer) {
+      this.logger.warn('pauseVideo()', { message: 'This peer has no subscribed video', peer: this });
+      return;
+    }
+
+    if (this.videoConsumer.paused) {
+      this.logger.warn('pauseVideo()', { message: 'Already paused', peer: this });
       return;
     }
 
     try {
       await this.pauseRemoteConsumer(this.videoConsumer?.id);
       this.videoConsumer.pause();
+      this.logger.debug('pauseVideo()', { peer: this });
     } catch (err) {
       this.logger.error('pauseVideo()', err);
     }
   }
 
   public async pauseAudio(): Promise<void> {
-    if (!this.audioConsumer || this.audioConsumer.paused) {
+    if (!this.audioConsumer) {
+      this.logger.warn('pauseAudio()', { message: 'This peer has no subscribed audio', peer: this });
+      return;
+    }
+
+    if (this.audioConsumer.paused) {
+      this.logger.warn('pauseAudio()', { message: 'Already paused', peer: this });
       return;
     }
 
     try {
       await this.pauseRemoteConsumer(this.audioConsumer?.id);
       this.audioConsumer.pause();
+      this.logger.debug('pauseAudio()', { peer: this });
     } catch (err) {
       this.logger.error('pauseAudio()', err);
     }
   }
 
   public async resumeVideo(): Promise<void> {
-    if (!this.videoConsumer || !this.videoConsumer.paused) {
+    if (!this.videoConsumer) {
+      this.logger.warn('resumeVideo()', { message: 'This peer has no subscribed video', peer: this });
+      return;
+    }
+
+    if (!this.videoConsumer.paused) {
+      this.logger.warn('resumeVideo()', { message: 'Video is not paused', peer: this });
       return;
     }
 
     try {
       await this.resumeRemoteConsumer(this.videoConsumer?.id);
       this.videoConsumer.resume();
+      this.logger.debug('resumeVideo()', { peer: this });
     } catch (err) {
       this.logger.error('resumeVideo()', err);
     }
   }
 
   public async resumeAudio(): Promise<void> {
-    if (!this.audioConsumer || !this.audioConsumer.paused) {
+    if (!this.audioConsumer) {
+      this.logger.warn('resumeAudio()', { message: 'This peer has no subscribed audio', peer: this });
       return;
     }
 
+    if (this.audioConsumer.paused) {
+      this.logger.warn('resumeAudio()', { message: 'Audio is not paused', peer: this });
+      return;
+    }
     try {
       await this.resumeRemoteConsumer(this.audioConsumer?.id);
       this.audioConsumer.resume();
+      this.logger.debug('resumeAudio()', { peer: this });
     } catch (err) {
       this.logger.error('resumeAudio()', err);
     }
@@ -289,6 +324,7 @@ class Peer {
 
   public async setVideoStreamPriority(priority: number): Promise<void> {
     if (!this.videoConsumer) {
+      this.logger.warn('setVideoStreamPriority()', { message: 'This peer has no subscribed audio', peer: this });
       return;
     }
 
@@ -297,6 +333,7 @@ class Peer {
 
   public async setAudioStreamPriority(priority: number): Promise<void> {
     if (!this.audioConsumer) {
+      this.logger.warn('setAudioStreamPriority()', { message: 'This peer has no subscribed audio', peer: this });
       return;
     }
 
@@ -306,7 +343,9 @@ class Peer {
   private async setConsumerPriority(params: SetConsumerPriorityParams): Promise<void> {
     try {
       await this.engine.network.socket.request(MEDIASOUP_EVENTS.setConsumerPriority, params);
+      this.logger.debug('setConsumerPriority()', { peer: this, params });
     } catch (err) {
+      this.logger.error('setConsumerPriority()', { peer: this, params });
       throw new Error('Can`t change stream priority');
     }
   }
@@ -340,6 +379,7 @@ class Peer {
         this.videoConsumer = new VideoConsumer(consumer);
       }
 
+      this.logger.debug(`Subscribed for ${producer.kind}`, { peer: this });
       this.observer.safeEmit(PEER_EVENTS.trackStart, { kind: producer.kind, track: consumer.track });
     } catch (error) {
       this.logger.error('createConsumer()', producer, error);
@@ -355,9 +395,10 @@ class Peer {
       });
 
       consumer.close();
+      this.logger.warn('Unsubscribed media', { peer: this, kind: consumer.kind });
     } catch (err) {
-      this.logger.error('closeConsumer()', consumer, err);
-      throw new Error('Error subscribe media');
+      this.logger.debug('closeConsumer()', { peer: this, consumer, error: err });
+      throw new Error('Error unsubscribe media');
     }
   }
 
@@ -383,8 +424,12 @@ class Peer {
         temporalLayer,
       });
     } catch (err) {
-      this.logger.error('changeConsumerPreferredLayers()', { consumerId: this.videoConsumer.id });
-      throw new Error('Error subscribe media');
+      this.logger.error('changeConsumerPreferredLayers()', {
+        peer: this,
+        consumer: this.videoConsumer,
+        error: err,
+      });
+      throw new Error('Error change preferred layer');
     }
   }
 
@@ -440,10 +485,11 @@ class Peer {
       if (producer.kind === ProducerKind.VIDEO) {
         this.setVideoProducer(producer);
       } else {
-        this.setVideoProducer(producer);
+        this.setAudioProducer(producer);
       }
 
-      this.engine.clientEventEmitter.safeEmit(PEER_EVENTS.mediaPublished, { kind: producer.kind });
+      this.logger.debug('Peer published media:', { peer: this, producer });
+      this.observer.safeEmit(PEER_EVENTS.mediaPublished, { kind: producer.kind });
     });
 
     this.observer.on(MEDIASOUP_EVENTS.producerClose, (producer: ProducerData) => {
@@ -453,28 +499,50 @@ class Peer {
         this.removeAudioProducer();
       }
 
-      this.engine.clientEventEmitter.safeEmit(PEER_EVENTS.mediaUnPublished, { kind: producer.kind });
+      this.logger.debug('Peer unpublished media:', { peer: this, producer });
+      this.observer.safeEmit(PEER_EVENTS.mediaUnPublished, { kind: producer.kind });
+    });
+
+    this.observer.on(MEDIASOUP_EVENTS.closeConsumer, (consumerId) => {
+      if (this.videoConsumer?.id === consumerId) {
+        this.videoConsumer?.close();
+        this.videoConsumer = undefined;
+        this.observer.safeEmit(PEER_EVENTS.trackEnd, { kind: 'video' });
+        this.logger.debug('Peer video track was ended:', { peer: this });
+        return;
+      }
+
+      if (this.audioConsumer?.id === consumerId) {
+        this.audioConsumer?.close();
+        this.audioConsumer = undefined;
+        this.logger.debug('Peer audio track was ended:', { peer: this });
+        this.observer.safeEmit(PEER_EVENTS.trackEnd, { kind: 'audio' });
+      }
     });
 
     this.observer.on(MEDIASOUP_EVENTS.pauseConsumer, (consumerId) => {
       if (this.videoConsumer?.id === consumerId) {
         this.videoConsumer?.pause();
+        this.logger.debug('Peer video track was paused:', { peer: this });
         return;
       }
 
       if (this.audioConsumer?.id === consumerId) {
         this.audioConsumer?.pause();
+        this.logger.debug('Peer audio track was paused:', { peer: this });
       }
     });
 
     this.observer.on(MEDIASOUP_EVENTS.resumeConsumer, (consumerId) => {
       if (this.videoConsumer?.id === consumerId) {
         this.videoConsumer?.resume();
+        this.logger.debug('Peer video track was resumed:', { peer: this });
         return;
       }
 
       if (this.audioConsumer?.id === consumerId) {
         this.audioConsumer?.resume();
+        this.logger.debug('Peer video track was resumed:', { peer: this });
       }
     });
 
@@ -487,6 +555,11 @@ class Peer {
 
       this.videoConsumer.setCurrentSpatialLayer(spatialLayer);
       this.videoConsumer.setCurrentTemporalLayer(temporalLayer);
+      this.logger.debug('Peer video track was changed preferred layers:', {
+        peer: this,
+        spatialLayer,
+        temporalLayer,
+      });
     });
   }
 }

package/src/engine/handlers/ChannelEventHandler.ts

@@ -1,22 +1,28 @@
 import { ChannelEvent, PeerResponse } from '../../types/common';
 import Engine from '../index';
 import { CHANNEL_EVENTS, CLIENT_EVENTS } from '../../constants/events';
+import Logger from '../Logger';
 
 class ChannelEventHandler {
   private readonly engine: Engine;
 
+  private readonly logger: Logger;
+
   constructor(engine: Engine) {
     this.engine = engine;
+    this.logger = new Logger('ChannelEvents');
   }
 
   public subscribeToEvents(): void {
     const { connection } = this.engine.network.socket;
     if (!connection) {
+      this.logger.error('subscribeToEvents()', { error: 'Socket connection not initialized' });
       throw new Error('Socket connection not initialized');
     }
 
     connection.on(CHANNEL_EVENTS.channelEvent, (event: ChannelEvent) => {
       this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelEvent, event);
+      this.logger.debug('New channel event', { event });
     });
 
     connection.on(CHANNEL_EVENTS.channelJoin, (peerData: PeerResponse) => {
@@ -26,22 +32,16 @@ class ChannelEventHandler {
         return;
       }
 
-      this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelJoin, peer);
+      this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.peerJoined, peer);
+      this.logger.debug('Peer joined to the channel', { peer });
     });
 
     connection.on(CHANNEL_EVENTS.channelLeave, (peerId: string) => {
       this.engine.removePeer(peerId);
-      this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelLeave, peerId);
+      this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.peerLeft, peerId);
+      this.logger.debug('Peer left the channel', { peerId });
     });
   }
-
-  public unsubscribeEvents(): void {
-    this.removeEventListeners(Object.values(CHANNEL_EVENTS));
-  }
-
-  private removeEventListeners(events: string[]): void {
-    events.forEach((event) => this.engine.network.socket.connection?.removeEventListener(event));
-  }
 }
 
 export default ChannelEventHandler;

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -1,17 +1,22 @@
 import { ChangePreferredLayersParams, ProducerData } from '../../types/common';
 import Engine from '../index';
 import { MEDIASOUP_EVENTS } from '../../constants/events';
+import Logger from '../Logger';
 
 class MediaSoupEventHandler {
   private readonly engine: Engine;
 
+  private readonly logger: Logger;
+
   constructor(engine: Engine) {
     this.engine = engine;
+    this.logger = new Logger('MediasoupEvents');
   }
 
   public subscribeToEvents(): void {
     const { connection } = this.engine.network.socket;
     if (!connection) {
+      this.logger.error('subscribeToEvents()', { error: 'Socket connection not initialized' });
       throw new Error('Socket connection not initialized');
     }
 
@@ -33,6 +38,15 @@ class MediaSoupEventHandler {
       peer.observer.safeEmit(MEDIASOUP_EVENTS.newProducer, producer);
     });
 
+    connection.on(MEDIASOUP_EVENTS.closeConsumer, (consumerId: string, peerId: string) => {
+      const peer = this.engine.peers.find((item) => item.id === peerId);
+      if (!peer) {
+        return;
+      }
+
+      peer.observer.safeEmit(MEDIASOUP_EVENTS.closeConsumer, consumerId);
+    });
+
     connection.on(MEDIASOUP_EVENTS.resumeConsumer, (consumerId: string, peerId: string) => {
       const peer = this.engine.peers.find((item) => item.id === peerId);
       if (!peer || peer.isMe) {
@@ -65,14 +79,6 @@ class MediaSoupEventHandler {
       });
     });
   }
-
-  public unsubscribeEvents(): void {
-    this.removeEventListeners(Object.values(MEDIASOUP_EVENTS));
-  }
-
-  private removeEventListeners(events: string[]): void {
-    events.forEach((event) => this.engine.network.socket.connection?.removeEventListener(event));
-  }
 }
 
 export default MediaSoupEventHandler;