@livedigital/client 1.13.1 → 1.15.1

package/dist/types/common.d.ts

@@ -125,9 +125,13 @@ export declare type CreateScreenVideoTrackOptions = CreateVideoTrackOptions & {
 export declare type CreateMicrophoneAudioTrackOptions = CreateTrackOptions & {
     encoderConfig?: AudioEncoderConfig;
 };
-export declare type CreateScreenAudioTrackOptions = CreateVideoTrackOptions & {
+export declare type CreateScreenAudioTrackOptions = CreateMicrophoneAudioTrackOptions & {
     encoderConfig?: AudioEncoderConfig;
 };
+export declare type CreateScreenMediaOptions = {
+    video: CreateScreenVideoTrackOptions;
+    audio: CreateScreenAudioTrackOptions;
+};
 export declare type Track = VideoTrack | AudioTrack;
 export declare enum TrackLabel {
     Camera = "camera",

package/package.json

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

package/src/constants/events.ts

@@ -1,7 +1,6 @@
 export const CHANNEL_EVENTS = {
   channelEvent: 'channel.event',
   channelJoin: 'channel.join',
-  channelBroadcast: 'channel.broadcast',
   channelGetPeers: 'channel.getPeers',
   channelLeave: 'peer.disconnected',
 };
@@ -10,8 +9,6 @@ export const CLIENT_EVENTS = {
   channelEvent: 'channel-event',
   peerJoined: 'peer-joined',
   peerLeft: 'peer-left',
-  channelLeave: 'peer-left',
-  peerBroadcasted: 'peer-broadcasted',
   channelRejoinRequired: 'channel-rejoin-required',
   devicesListUpdated: 'devices-list-updated',
 };
@@ -24,14 +21,14 @@ export const PEER_EVENTS = {
   trackEnd: 'track-end',
 };
 
-export const SOCKET_IO_EVENTS = {
-  connected: 'connected',
-  reconnecting: 'reconnecting',
-  reconnected: 'reconnected',
-  disconnected: 'disconnected',
-  reconnect: 'reconnect',
-  error: 'error',
-};
+export enum SocketIOEvents {
+  Connected = 'connected',
+  Reconnecting = 'reconnecting',
+  Reconnected = 'reconnected',
+  Disconnected = 'disconnected',
+  Reconnect = 'reconnect',
+  Error = 'error',
+}
 
 export const MEDIASOUP_EVENTS = {
   newProducer: 'peer.newProducer',

package/src/engine/Peer.ts

@@ -235,6 +235,8 @@ class Peer {
         rtpCapabilities: this.engine.media.mediasoupDevice.rtpCapabilities,
         appData: {
           peerId: this.engine.mySocketId,
+          appId: this.engine.appId,
+          channelId: this.engine.channelId,
         },
         producerPeerId: this.id,
       }) as ConsumerOptions;
@@ -299,6 +301,10 @@ class Peer {
   }
 
   private handleNewProducer(producerData: ProducerData): void {
+    if (this.producers.get(producerData.id)) {
+      return;
+    }
+
     const producer = new PeerProducer(producerData);
     this.producers.set(producer.id, producer);
     this.logger.debug('Peer published media:', { peer: this, producer });

package/src/engine/handlers/ChannelEventHandler.ts

@@ -26,27 +26,11 @@ class ChannelEventHandler {
     });
 
     connection.on(CHANNEL_EVENTS.channelJoin, (peerData: PeerResponse) => {
-      this.engine.setPeer(peerData);
-      const peer = this.engine.peers.find((item) => item.id === peerData.id);
-      if (!peer) {
-        return;
-      }
-
+      const peer = this.engine.setPeer(peerData);
       this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.peerJoined, peer);
       this.logger.debug('Peer joined to the channel', { peer });
     });
 
-    connection.on(CHANNEL_EVENTS.channelBroadcast, (peerData: PeerResponse) => {
-      this.engine.setPeer(peerData);
-      const peer = this.engine.peers.find((item) => item.id === peerData.id);
-      if (!peer) {
-        return;
-      }
-
-      this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.peerBroadcasted, peer);
-      this.logger.debug('Peer broadcasted to the channel', { peer });
-    });
-
     connection.on(CHANNEL_EVENTS.channelLeave, (peerId: string) => {
       this.engine.removePeer(peerId);
       this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.peerLeft, peerId);

package/src/engine/index.ts

@@ -1,16 +1,15 @@
 import { RtpCapabilities } from 'mediasoup-client/lib/RtpParameters';
 import {
-  PeerResponse,
-  JoinChannelParams,
-  SocketResponse,
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
-  CreateScreenVideoTrackOptions,
-  CreateScreenAudioTrackOptions,
-  Track,
-  TrackLabel,
+  CreateScreenMediaOptions,
   EndTrackPayload,
+  JoinChannelParams,
+  PeerResponse,
+  SocketResponse,
   StartTrackPayload,
+  Track,
+  TrackLabel,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
@@ -21,11 +20,7 @@ import ChannelEventHandler from './handlers/ChannelEventHandler';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import Logger from './Logger';
 import {
-  CHANNEL_EVENTS,
-  CLIENT_EVENTS,
-  MEDIASOUP_EVENTS,
-  PEER_EVENTS,
-  SOCKET_IO_EVENTS,
+  CHANNEL_EVENTS, CLIENT_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS, SocketIOEvents,
 } from '../constants/events';
 
 type EngineParams = {
@@ -52,6 +47,12 @@ class Engine {
 
   private isJoined = false;
 
+  private app?: string;
+
+  private channel?: string;
+
+  private isRoomJoining = false;
+
   private logger: Logger;
 
   constructor(params: EngineParams) {
@@ -86,7 +87,8 @@ class Engine {
     try {
       this.initialized = false;
       this.isJoined = false;
-
+      this.app = undefined;
+      this.channel = undefined;
       this.network.socket.disconnect();
       this.peersRepository.clear();
       await this.unpublish();
@@ -109,10 +111,10 @@ class Engine {
   }
 
   private watchSocketState(): void {
-    this.network.socket.observer.on('state', (state: string) => {
+    this.network.socket.observer.on('state', ({ state }: { state: SocketIOEvents }) => {
       this.clientEventEmitter.emit(state);
 
-      if (state === SOCKET_IO_EVENTS.reconnected) {
+      if (state === SocketIOEvents.Reconnected) {
         this.network.socket.disconnect();
         this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
       }
@@ -129,29 +131,28 @@ class Engine {
 
   public async join(params: JoinChannelParams): Promise<void> {
     try {
-      this.logger.debug('join()');
-      const { webSocketUrl } = await this.network.loadBalancerClient.getNode({ channelId: params.channelId });
+      this.logger.debug('join()', { params });
+      this.isRoomJoining = true;
+      const { webSocketUrl } = await this.getAvailableNode({ channelId: params.channelId });
       this.network.socket.connect(webSocketUrl);
-      await this.network.socket.request(CHANNEL_EVENTS.channelJoin, params);
-      await this.initialize();
-      const { peers } = await this.network.socket.request(CHANNEL_EVENTS.channelGetPeers) as { peers: PeerResponse[] };
-      peers.forEach((peer: PeerResponse) => this.setPeer(peer));
-      this.channelEventsHandler.subscribeToEvents();
-      this.mediaSoupEventsHandler.subscribeToEvents();
-      this.isJoined = true;
-      this.logger.debug(`Successfully joined to ${params.channelId}. Peers in channel:`, this.peersRepository);
+      await this.waitForSocketConnection();
+      await this.performJoin(params);
     } catch (error) {
       this.logger.error('join()', { error });
-      throw new Error(error);
+      throw error;
+    } finally {
+      this.isRoomJoining = false;
     }
   }
 
-  public setPeer(peerData: PeerResponse): void {
-    this.peersRepository.set(peerData.id, new Peer({
+  public setPeer(peerData: PeerResponse): Peer {
+    const peer = new Peer({
       ...peerData,
       engine: this,
       loginDate: new Date(),
-    }));
+    });
+    this.peersRepository.set(peer.id, peer);
+    return peer;
   }
 
   public removePeer(peerId: string): void {
@@ -195,7 +196,7 @@ class Engine {
   async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track> {
     const trackParams = Media.getCameraVideoTrackParams(options);
     try {
-      const track = await this.media.createUserMediaTrack({
+      const [track] = await this.media.createUserMediaTracks({
         audio: false,
         video: trackParams.videoTrackOptions,
       });
@@ -213,7 +214,7 @@ class Engine {
 
   async createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track> {
     try {
-      const track = await this.media.createUserMediaTrack({
+      const [track] = await this.media.createUserMediaTracks({
         video: false,
         audio: {
           deviceId: options?.deviceId,
@@ -233,50 +234,38 @@ class Engine {
     }
   }
 
-  async createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track> {
-    const trackParams = Media.getScreenVideoTrackParams(options);
+  async createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]> {
+    const videoTrackParams = Media.getScreenVideoTrackParams(options?.video);
     try {
-      const track = await this.media.createDisplayMediaTrack({
-        audio: false,
-        video: trackParams.videoTrackOptions,
+      const tracks = await this.media.createDisplayMediaTracks({
+        audio: options?.audio,
+        video: videoTrackParams.videoTrackOptions,
       });
 
-      track.mediaStreamTrack.addEventListener('ended', () => {
-        this.unpublish(track);
-      });
+      tracks.forEach((track) => {
+        track.mediaStreamTrack.addEventListener('ended', () => {
+          this.unpublish(track);
+        });
 
-      track.setLabel(TrackLabel.ScreenVideo);
-      track.setEncoderConfig(trackParams.encoderConfig);
+        if (track.kind === 'video') {
+          track.setLabel(TrackLabel.ScreenVideo);
+          track.setEncoderConfig(videoTrackParams.encoderConfig);
+          this.logger.debug('createScreenMediaTrack()', { trackParams: videoTrackParams, track });
+          return;
+        }
 
-      this.logger.debug('createScreenVideoTrack()', { trackParams, track });
-      return track;
-    } catch (error) {
-      this.logger.error('createScreenVideoTrack()', { error, trackParams });
-      throw new Error(`Can not create screen video track: ${error.message}`);
-    }
-  }
+        track.setLabel(TrackLabel.ScreenAudio);
+        if (options?.audio) {
+          track.setEncoderConfig(options.audio);
+        }
 
-  async createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track> {
-    try {
-      const track = await this.media.createDisplayMediaTrack({
-        video: false,
-        audio: true,
+        this.logger.debug('createScreenMediaTrack()', { trackParams: options?.audio, track });
       });
 
-      track.mediaStreamTrack.addEventListener('ended', () => {
-        this.unpublish(track);
-      });
-
-      track.setLabel(TrackLabel.ScreenAudio);
-      if (options?.encoderConfig) {
-        track.setEncoderConfig(options.encoderConfig);
-      }
-
-      this.logger.debug('createScreenAudioTrack()', { options, track });
-      return track;
+      return tracks;
     } catch (error) {
-      this.logger.error('createScreenAudioTrack()', { error, options });
-      throw new Error(`Can not create screen audio track: ${error.message}`);
+      this.logger.error('createScreenMediaTrack()', { error, trackParams: videoTrackParams });
+      throw new Error(`Can not create screen media tracks: ${error.message}`);
     }
   }
 
@@ -364,6 +353,63 @@ class Engine {
   deleteTrack(tracks: Track): void {
     return this.media.deleteTrack(tracks);
   }
+
+  public get channelId(): string | undefined {
+    return this.channel;
+  }
+
+  public get appId(): string | undefined {
+    return this.app;
+  }
+
+  private async getAvailableNode({ channelId }: { channelId: string }): Promise<{ webSocketUrl: string }> {
+    try {
+      const response = await this.network.loadBalancerClient.getNode({ channelId });
+      return { webSocketUrl: response.webSocketUrl };
+    } catch (error) {
+      this.logger.error('getAvailableNode()', { error: 'No available nodes' });
+      throw error;
+    }
+  }
+
+  private waitForSocketConnection(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const onSocketStateChange = async (data: { state: SocketIOEvents, error?: string }) => {
+        const { error, state } = data;
+        if (error) {
+          this.network.socket.observer.removeListener('state', onSocketStateChange);
+          reject(error);
+          return;
+        }
+
+        if (this.isRoomJoining && state === SocketIOEvents.Connected) {
+          this.network.socket.observer.removeListener('state', onSocketStateChange);
+          resolve();
+        }
+      };
+
+      this.network.socket.observer.on('state', onSocketStateChange);
+    });
+  }
+
+  private async performJoin(params: JoinChannelParams): Promise<void> {
+    try {
+      await this.network.socket.request(CHANNEL_EVENTS.channelJoin, params);
+      await this.initialize();
+      const { peers } = await this.network.socket
+        .request(CHANNEL_EVENTS.channelGetPeers) as { peers: PeerResponse[] };
+      peers.forEach((peer: PeerResponse) => this.setPeer(peer));
+      this.channelEventsHandler.subscribeToEvents();
+      this.mediaSoupEventsHandler.subscribeToEvents();
+      this.app = params.appId;
+      this.channel = params.channelId;
+      this.isJoined = true;
+      this.logger.debug(`Successfully joined to ${params.channelId}. Peers in channel:`, this.peersRepository);
+    } catch (error) {
+      this.logger.error('performJoin()', { error });
+      throw error;
+    }
+  }
 }
 
 export default Engine;

package/src/engine/media/index.ts

@@ -46,28 +46,33 @@ class Media {
       .find((c) => c.mimeType.toLowerCase() === `video/${track.getPreferredCodec()}`);
   }
 
-  private createTrack(stream: MediaStream): Track {
-    const mediaStreamTrack = stream.getTracks()[0];
-
-    const track = mediaStreamTrack.kind === 'audio'
-      ? new AudioTrack(mediaStreamTrack)
-      : new VideoTrack(mediaStreamTrack);
-
-    this.tracks.set(track.id, track);
-    this.#logger.debug('createTrack() track created', { streamId: stream.id, trackId: track.id, kind: track.kind });
-
-    return track;
+  private createTracks(stream: MediaStream): Track[] {
+    const mediaStreamTracks = stream.getTracks();
+    return mediaStreamTracks.map((mediaStreamTrack) => {
+      const track = mediaStreamTrack.kind === 'audio'
+        ? new AudioTrack(mediaStreamTrack)
+        : new VideoTrack(mediaStreamTrack);
+
+      this.tracks.set(track.id, track);
+      this.#logger.debug('createTrack() track created', {
+        streamId: stream.id,
+        trackId: track.id,
+        kind: track.kind,
+      });
+
+      return track;
+    });
   }
 
-  async createUserMediaTrack(constraints: MediaStreamConstraints): Promise<Track> {
+  async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
     const stream = await navigator.mediaDevices.getUserMedia(constraints);
     this.#logger.debug('createUserMediaTrack() stream created', { streamId: stream.id });
-    return this.createTrack(stream);
+    return this.createTracks(stream);
   }
 
-  async createDisplayMediaTrack(constraints: MediaStreamConstraints): Promise<Track> {
+  async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
     const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
-    return this.createTrack(stream);
+    return this.createTracks(stream);
   }
 
   deleteTrack(track: Track) {

package/src/engine/network/Socket.ts

@@ -1,6 +1,6 @@
 import { io, Socket } from 'socket.io-client';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { SOCKET_IO_EVENTS } from '../../constants/events';
+import { SocketIOEvents } from '../../constants/events';
 import { SocketResponse } from '../../types/common';
 import Logger from '../Logger';
 
@@ -41,20 +41,20 @@ class SocketIO {
 
     connection.on('connect', () => {
       const state = !this.reconnectingAttempt
-        ? SOCKET_IO_EVENTS.connected
-        : SOCKET_IO_EVENTS.reconnected;
+        ? SocketIOEvents.Connected
+        : SocketIOEvents.Reconnected;
 
       this.isConnected = true;
       this.reconnectingAttempt = 0;
 
       this.logger.debug('connection.on(`connect`)');
-      this.observer.safeEmit('state', state);
+      this.observer.safeEmit('state', { state });
     });
 
     connection.on('connect_error', (error: unknown) => {
       this.connectionError = error as string;
       this.logger.error('connection.on(`connect_error`)', error);
-      this.observer.safeEmit('state', SOCKET_IO_EVENTS.error);
+      this.observer.safeEmit('state', { state: SocketIOEvents.Error, error });
     });
 
     connection.on('disconnect', ((reason: string) => {
@@ -62,18 +62,18 @@ class SocketIO {
       this.reconnectingAttempt = 0;
       this.disconnectReason = reason;
       this.logger.error('connection.on(`disconnect`)', reason);
-      this.observer.safeEmit('state', SOCKET_IO_EVENTS.disconnected);
+      this.observer.safeEmit('state', { state: SocketIOEvents.Disconnected });
     }));
 
     connection.io.on('reconnect_attempt', (attempt: number) => {
       this.reconnectingAttempt = attempt;
       this.logger.warn('connection.on(`reconnect_attempt`)', attempt);
-      this.observer.safeEmit('state', SOCKET_IO_EVENTS.reconnecting);
+      this.observer.safeEmit('state', { state: SocketIOEvents.Reconnecting });
     });
 
     connection.io.on('reconnect', () => {
       this.logger.debug('connection.on(`reconnect`)');
-      this.observer.safeEmit('state', SOCKET_IO_EVENTS.reconnect);
+      this.observer.safeEmit('state', { state: SocketIOEvents.Reconnect });
     });
   }
 

package/src/index.ts

@@ -2,8 +2,7 @@ import {
   AvailableMediaDevices,
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
-  CreateScreenAudioTrackOptions,
-  CreateScreenVideoTrackOptions,
+  CreateScreenMediaOptions,
   JoinChannelParams,
   Track,
 } from './types/common';
@@ -96,12 +95,8 @@ class Client {
     return this.engine.createMicrophoneAudioTrack(options);
   }
 
-  createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track> {
-    return this.engine.createScreenVideoTrack(options);
-  }
-
-  createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track> {
-    return this.engine.createScreenAudioTrack(options);
+  createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]> {
+    return this.engine.createScreenMediaTracks(options);
   }
 
   deleteTrack(track: Track): void {

package/src/types/common.ts

@@ -152,10 +152,15 @@ export type CreateMicrophoneAudioTrackOptions = CreateTrackOptions & {
   encoderConfig?: AudioEncoderConfig,
 };
 
-export type CreateScreenAudioTrackOptions = CreateVideoTrackOptions & {
+export type CreateScreenAudioTrackOptions = CreateMicrophoneAudioTrackOptions & {
   encoderConfig?: AudioEncoderConfig,
 };
 
+export type CreateScreenMediaOptions = {
+  video: CreateScreenVideoTrackOptions,
+  audio: CreateScreenAudioTrackOptions,
+};
+
 export type Track = VideoTrack | AudioTrack;
 
 export enum TrackLabel {