@livedigital/client 1.7.0 → 1.10.0

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

@@ -0,0 +1,70 @@
+import { Producer } from 'mediasoup-client/lib/Producer';
+import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import { EncoderConfig, TrackLabel } from 'types/common';
+
+class BaseTrack {
+  readonly #mediaStreamTrack: MediaStreamTrack;
+
+  protected encoderConfig: EncoderConfig = {};
+
+  private producer?: Producer;
+
+  private label: TrackLabel = TrackLabel.Unknown;
+
+  constructor(mediaStreamTrack: MediaStreamTrack) {
+    this.#mediaStreamTrack = mediaStreamTrack;
+  }
+
+  get mediaStreamTrack(): MediaStreamTrack {
+    return this.#mediaStreamTrack;
+  }
+
+  get id(): string {
+    return this.mediaStreamTrack.id;
+  }
+
+  get kind(): MediaKind {
+    return this.mediaStreamTrack.kind as MediaKind;
+  }
+
+  get producerId(): string | undefined {
+    return this.producer?.id;
+  }
+
+  get isPublished(): boolean {
+    return this.producer
+      ? !this.producer.closed
+      : false;
+  }
+
+  getLabel(): TrackLabel {
+    return this.label;
+  }
+
+  setLabel(label: TrackLabel): void {
+    this.label = label;
+  }
+
+  setEncoderConfig(encoderConfig: EncoderConfig): void {
+    this.encoderConfig = encoderConfig;
+  }
+
+  getEncoderConfig(): EncoderConfig {
+    return this.encoderConfig;
+  }
+
+  setProducer(producer: Producer): void {
+    this.producer = producer;
+  }
+
+  getProducer(): Producer | undefined {
+    return this.producer;
+  }
+
+  closeProducer(): void {
+    this.producer?.close();
+    this.producer = undefined;
+  }
+}
+
+export default BaseTrack;

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

@@ -0,0 +1,5 @@
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+
+export default interface TrackWithCodecOptions {
+  getCodecOptions(): ProducerCodecOptions;
+}

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

@@ -0,0 +1,5 @@
+import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+
+export default interface TrackWithEncodings {
+  getEncodings(): RtpEncodingParameters[];
+}

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

@@ -0,0 +1,29 @@
+import { WEBCAM_SIMULCAST_ENCODINGS } from 'constants/simulcastEncodings';
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+import { VideoCodec, VideoEncoderConfig } from 'types/common';
+import BaseTrack from './BaseTrack';
+import TrackWithCodecOptions from './TrackWithCodecOptions';
+import TrackWithEncodings from './TrackWithEncodings';
+
+class VideoTrack extends BaseTrack implements TrackWithCodecOptions, TrackWithEncodings {
+  getEncoderConfig(): VideoEncoderConfig {
+    return this.encoderConfig;
+  }
+
+  getCodecOptions(): ProducerCodecOptions {
+    return {
+      videoGoogleStartBitrate: this.getEncoderConfig().videoGoogleStartBitrate || 1000,
+    };
+  }
+
+  getPreferredCodec(): VideoCodec {
+    return this.getEncoderConfig().preferredCodec || 'h264';
+  }
+
+  getEncodings(): RtpEncodingParameters[] {
+    return this.getEncoderConfig().encodings || WEBCAM_SIMULCAST_ENCODINGS;
+  }
+}
+
+export default VideoTrack;

package/src/engine/network/LoadBalancerClient.ts

@@ -2,19 +2,33 @@ import axios, { AxiosInstance } from 'axios';
 import qs from 'qs';
 import { GetNodeResponse } from '../../types/common';
 
+export type LoadBalancerApiClientParams = {
+  baseURL?: string;
+  timeout?: number;
+  customNode?: GetNodeResponse;
+};
+
 class LoadBalancerApiClient {
   private readonly api: AxiosInstance;
 
-  constructor() {
+  private customNode?: GetNodeResponse;
+
+  constructor(params: LoadBalancerApiClientParams) {
+    const { baseURL, timeout, customNode } = params;
     this.api = axios.create({
-      baseURL: process.env.LIVEDIGITAL_APP_LOAD_BALANCER_BASE_URL,
-      timeout: 5000,
+      baseURL: baseURL || process.env.LIVEDIGITAL_APP_LOAD_BALANCER_BASE_URL,
+      timeout: timeout || 5000,
       withCredentials: false,
-      paramsSerializer: (params) => qs.stringify(params),
+      paramsSerializer: (data) => qs.stringify(data),
     });
+    this.customNode = customNode;
   }
 
   async getNode({ channelId }: { channelId: string }): Promise<GetNodeResponse> {
+    if (this.customNode) {
+      return this.customNode;
+    }
+
     const { data } = await this.api.get<GetNodeResponse>('/nodes/best', {
       params: { channelId },
     });

package/src/engine/network/index.ts

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

package/src/engine/system/index.ts

@@ -1,29 +1,32 @@
-import { VIDEO_CONSTRAINS } from '../../constants/videoConstrains';
-import { AudioTrackConstraints, VideoTrackConstraints } from '../../types/common';
+import { CLIENT_EVENTS } from 'constants/events';
+import EnhancedEventEmitter from 'EnhancedEventEmitter';
+import { AvailableMediaDevices } from 'types/common';
 import Logger from '../Logger';
 
+type SystemParams = {
+  clientEventEmitter: EnhancedEventEmitter,
+};
+
 class System {
   public isEnableVideoDevicesLock = false;
 
   public isEnableAudioDevicesLock = false;
 
-  public isDevicesLoaded = false;
-
-  public videoStream?: MediaStream;
-
-  public audioStream?: MediaStream;
+  public isDevicesDetected = false;
 
   public availableVideoDevices: MediaDeviceInfo[] = [];
 
   public availableAudioDevices: MediaDeviceInfo[] = [];
 
-  public currentAudioDeviceId?: string;
+  private isMediaDevicesAccessGranted = false;
 
-  public currentVideoDeviceId?: string;
+  public clientEventEmitter: EnhancedEventEmitter;
 
   private readonly logger: Logger;
 
-  constructor() {
+  constructor(params: SystemParams) {
+    const { clientEventEmitter } = params;
+    this.clientEventEmitter = clientEventEmitter;
     this.logger = new Logger('System');
     this.listenDevices();
   }
@@ -36,24 +39,6 @@ class System {
     this.isEnableAudioDevicesLock = value;
   }
 
-  setCurrentVideoDevice(deviceId: string): void {
-    const isExistsDevice = this.availableVideoDevices.find((device) => device.deviceId === deviceId);
-    if (!isExistsDevice) {
-      throw new Error('Unknown video device id');
-    }
-
-    this.currentVideoDeviceId = deviceId;
-  }
-
-  setCurrentAudioDevice(deviceId: string): void {
-    const isExistsDevice = this.availableAudioDevices.find((device) => device.deviceId === deviceId);
-    if (!isExistsDevice) {
-      throw new Error('Unknown audio device id');
-    }
-
-    this.currentAudioDeviceId = deviceId;
-  }
-
   setAvailableVideoDevices(availableVideoDevices: MediaDeviceInfo[]): void {
     this.availableVideoDevices = availableVideoDevices;
   }
@@ -62,199 +47,80 @@ class System {
     this.availableAudioDevices = availableAudioDevices;
   }
 
-  getVideoConstraints(videoTrackConstraints?: VideoTrackConstraints): MediaTrackConstraints {
-    const constraints = {
-      ...VIDEO_CONSTRAINS.hd,
-      deviceId: this.currentVideoDeviceId || undefined,
-      frameRate: 15,
-    };
-
-    if (!videoTrackConstraints) {
-      return constraints;
-    }
-
-    return {
-      ...constraints,
-      ...videoTrackConstraints,
-    };
-  }
-
-  getAudioConstraints(audioTrackConstraints?: AudioTrackConstraints): MediaTrackConstraints {
-    const constraints = {
-      autoGainControl: true,
-      deviceId: this.currentAudioDeviceId || undefined,
-    };
-
-    if (!audioTrackConstraints) {
-      return constraints;
-    }
-
-    return {
-      ...constraints,
-      ...audioTrackConstraints,
-    };
-  }
-
-  async getVideoTrack(): Promise<MediaStreamTrack> {
-    const videoStream = this.videoStream || await this.startVideoStream();
-    const [track] = videoStream.getVideoTracks();
-    return track;
-  }
-
-  async getAudioTrack(): Promise<MediaStreamTrack> {
-    const videoStream = this.videoStream || await this.startAudioStream();
-    const [track] = videoStream.getAudioTracks();
-    return track;
-  }
-
-  async startVideoStream(videoTrackConstraints?: VideoTrackConstraints): Promise<MediaStream> {
-    if (!this.videoStream || !this.videoStream.active) {
-      try {
-        this.videoStream = await navigator.mediaDevices.getUserMedia({
-          video: this.getVideoConstraints(videoTrackConstraints),
-        });
-        this.logger.debug('startVideoStream()');
-      } catch (error) {
-        this.logger.error('startVideoStream()', { error });
-
-        if (error.name === 'NotReadableError') {
-          this.videoStream = undefined;
-          throw new Error('DeviceIsBusy');
-        }
-
-        if (error.name === 'This action is not allowed') {
-          throw new Error('NotAllowedError');
-        }
-
-        throw new Error('Can`t start video stream');
+  async requestMediaDevicesAccess(): Promise<void> {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({
+        video: true,
+        audio: true,
+      });
+      stream.getTracks().forEach((track) => track.stop());
+      this.isMediaDevicesAccessGranted = true;
+    } catch (error) {
+      this.logger.error('getUserMedia()', { error });
+      if (error.name === 'NotReadableError') {
+        throw new Error('DeviceIsBusy');
       }
     }
-
-    return this.videoStream;
   }
 
-  async startAudioStream(audioTrackConstraints?: AudioTrackConstraints): Promise<MediaStream> {
-    if (!this.audioStream || !this.audioStream.active) {
-      try {
-        this.audioStream = await navigator.mediaDevices.getUserMedia({
-          audio: this.getAudioConstraints(audioTrackConstraints),
-        });
-        this.logger.debug('startAudioStream()');
-      } catch (error) {
-        this.logger.error('startAudioStream()', { error });
-
-        if (error.name === 'NotReadableError') {
-          this.audioStream = undefined;
-          throw new Error('DeviceIsBusy');
-        }
-
-        if (error.name === 'NotAllowedError') {
-          throw new Error('Device access denied');
-        }
-
-        throw new Error('Can`t start audio stream');
+  async refreshAvailableMediaDevicesList(): Promise<void> {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    const videoDevices = [] as MediaDeviceInfo[];
+    const audioDevices = [] as MediaDeviceInfo[];
+    devices.forEach((device) => {
+      if (device.deviceId === '') {
+        return;
       }
-    }
-
-    return this.audioStream;
-  }
-
-  async detectDevices(): Promise<void> {
-    this.isDevicesLoaded = false;
 
-    try {
-      const mediaDevices = await navigator.mediaDevices.enumerateDevices();
-
-      const availableDevicesTypes = {
-        video: !!mediaDevices.find((device) => device.kind === 'videoinput'),
-        audio: !!mediaDevices.find((device) => device.kind === 'audioinput'),
-      };
-
-      try {
-        await navigator.mediaDevices.getUserMedia({
-          video: availableDevicesTypes.video && this.getVideoConstraints(),
-          audio: availableDevicesTypes.audio && this.getAudioConstraints(),
-        });
-      } catch (error) {
-        this.logger.error('getUserMedia()', { error });
-        if (error.name === 'NotReadableError') {
-          throw new Error('DeviceIsBusy');
-        }
+      if (device.deviceId === 'default') {
+        return;
       }
 
-      const devices = await navigator.mediaDevices.enumerateDevices();
-
-      const videoDevices = [] as MediaDeviceInfo[];
-      const audioDevices = [] as MediaDeviceInfo[];
-      devices.forEach((device) => {
-        if (device.deviceId === 'default') {
-          return;
-        }
+      if (device.kind === 'videoinput') {
+        videoDevices.push(device);
+      }
 
-        if (device.kind === 'videoinput') {
-          videoDevices.push(device);
-        }
+      if (device.kind === 'audioinput') {
+        audioDevices.push(device);
+      }
+    });
 
-        if (device.kind === 'audioinput') {
-          audioDevices.push(device);
-        }
-      });
+    this.setAvailableVideoDevices(videoDevices);
+    this.setAvailableAudioDevices(audioDevices);
 
-      this.setAvailableVideoDevices(videoDevices);
-      this.setAvailableAudioDevices(audioDevices);
-      this.isDevicesLoaded = true;
-      this.logger.debug('detectDevices()', { videoDevices, audioDevices });
-    } catch (error) {
-      this.logger.error('detectDevices()', { error });
-      throw new Error('Can`t detect devices');
-    }
+    this.logger.debug('Devices list updated');
   }
 
-  listenDevices(): void {
-    navigator.mediaDevices.ondevicechange = () => {
-      if (this.isDevicesLoaded) {
-        this.logger.debug('Available devices list was changed');
-        this.detectDevices();
-      }
-    };
-  }
-
-  stopVideoStream(): void {
-    if (!this.videoStream) {
-      this.logger.warn('stopVideoStream()', { message: 'No available video stream' });
+  async detectDevices(): Promise<void> {
+    if (this.isDevicesDetected) {
       return;
     }
 
-    this.videoStream.getTracks().forEach((track) => {
-      track.stop();
-    });
-
-    this.videoStream = undefined;
-    this.logger.debug('stopVideoStream()');
-  }
-
-  stopAudioStream(): void {
-    if (!this.audioStream) {
-      this.logger.warn('stopVideoStream()', { message: 'No available audio stream' });
-      return;
+    if (!this.isMediaDevicesAccessGranted) {
+      await this.requestMediaDevicesAccess();
     }
 
-    this.audioStream.getTracks().forEach((track) => {
-      track.stop();
+    navigator.mediaDevices.addEventListener('devicechange', () => {
+      this.refreshAvailableMediaDevicesList();
     });
 
-    this.audioStream = undefined;
-    this.logger.debug('stopAudioStream()');
-  }
+    await this.refreshAvailableMediaDevicesList();
 
-  async restartVideoStream(): Promise<void> {
-    this.stopVideoStream();
-    await this.startVideoStream();
+    this.isDevicesDetected = true;
   }
 
-  async restartAudioStream(): Promise<void> {
-    this.stopAudioStream();
-    await this.startAudioStream();
+  listenDevices(): void {
+    navigator.mediaDevices.ondevicechange = async () => {
+      if (!this.isDevicesDetected) {
+        return;
+      }
+
+      await this.refreshAvailableMediaDevicesList();
+      this.clientEventEmitter.safeEmit(CLIENT_EVENTS.devicesListUpdated, {
+        audio: this.availableAudioDevices,
+        video: this.availableVideoDevices,
+      } as AvailableMediaDevices);
+    };
   }
 }
 

package/src/index.ts

@@ -1,20 +1,39 @@
 import {
   AvailableMediaDevices,
+  CreateCameraVideoTrackOptions,
+  CreateMicrophoneAudioTrackOptions,
+  CreateScreenAudioTrackOptions,
+  CreateScreenVideoTrackOptions,
   JoinChannelParams,
-  PublishAudioOptions,
-  PublishVideoOptions,
+  Track,
 } from './types/common';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
 import Engine from './engine';
 import Peer from './engine/Peer';
+import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
+
+type ClientParams = {
+  network?: {
+    loadbalancer?: LoadBalancerApiClientParams,
+  },
+};
 
 class Client {
   private readonly engine: Engine;
 
   private readonly _observer = new EnhancedEventEmitter();
 
-  constructor() {
-    this.engine = new Engine(this.observer);
+  constructor(params: ClientParams) {
+    const { network } = params;
+    this.engine = new Engine({
+      clientEventEmitter: this.observer,
+      network: {
+        loadbalancer: {
+          baseURL: network?.loadbalancer?.baseURL,
+          customNode: network?.loadbalancer?.customNode,
+        },
+      },
+    });
   }
 
   get observer(): EnhancedEventEmitter {
@@ -29,22 +48,6 @@ class Client {
     return this.engine.peers;
   }
 
-  get isVideoEnabled(): boolean {
-    return !!this.engine.media.videoProducer;
-  }
-
-  get isVideoPaused(): boolean {
-    return !!this.engine.media.videoProducer?.paused;
-  }
-
-  get isAudioEnabled(): boolean {
-    return !!this.engine.media.audioProducer;
-  }
-
-  get isAudioPaused(): boolean {
-    return !!this.engine.media.audioProducer?.paused;
-  }
-
   get availableVideoDevices(): MediaDeviceInfo[] {
     return this.engine.system.availableVideoDevices;
   }
@@ -53,14 +56,6 @@ class Client {
     return this.engine.system.availableAudioDevices;
   }
 
-  get currentAudioDeviceId(): string | undefined {
-    return this.engine.system.currentAudioDeviceId;
-  }
-
-  get currentVideoDeviceId(): string | undefined {
-    return this.engine.system.currentVideoDeviceId;
-  }
-
   async detectDevices(): Promise<AvailableMediaDevices> {
     await this.engine.system.detectDevices();
     return {
@@ -69,30 +64,6 @@ class Client {
     };
   }
 
-  async getVideoStream(): Promise<MediaStream> {
-    return this.engine.system.videoStream || this.engine.system.startVideoStream();
-  }
-
-  async getAudioStream(): Promise<MediaStream> {
-    return this.engine.system.audioStream || this.engine.system.startAudioStream();
-  }
-
-  async getVideoTrack(): Promise<MediaStreamTrack> {
-    return this.engine.system.getVideoTrack();
-  }
-
-  async getAudioTrack(): Promise<MediaStreamTrack> {
-    return this.engine.system.getAudioTrack();
-  }
-
-  setVideoDevice(deviceId: string): void {
-    this.engine.system.setCurrentVideoDevice(deviceId);
-  }
-
-  setAudioDevice(deviceId: string): void {
-    this.engine.system.setCurrentAudioDevice(deviceId);
-  }
-
   join(params: JoinChannelParams): Promise<void> {
     return this.engine.join(params);
   }
@@ -101,36 +72,36 @@ class Client {
     return this.engine.release();
   }
 
-  publishVideo(track?: MediaStreamTrack, options?: PublishVideoOptions): Promise<void> {
-    return this.engine.publishVideo(track, options);
+  publish(tracks: Track | Track[]): Promise<void> {
+    return this.engine.publish(tracks);
   }
 
-  publishAudio(track?: MediaStreamTrack, options?: PublishAudioOptions): Promise<void> {
-    return this.engine.publishAudio(track, options);
+  unpublish(tracks?: Track | Track[]): Promise<void> {
+    return this.engine.unpublish(tracks);
   }
 
-  unpublishVideo(): Promise<void> {
-    return this.engine.unpublishVideo();
+  pause(track: Track): Promise<void> {
+    return this.engine.pause(track);
   }
 
-  unpublishAudio(): Promise<void> {
-    return this.engine.unpublishAudio();
+  resume(track: Track): Promise<void> {
+    return this.engine.resume(track);
   }
 
-  pauseVideo(): Promise<void> {
-    return this.engine.pauseVideo();
+  createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track | null> {
+    return this.engine.createCameraVideoTrack(options);
   }
 
-  resumeVideo(): Promise<void> {
-    return this.engine.resumeVideo();
+  createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track | null> {
+    return this.engine.createMicrophoneAudioTrack(options);
   }
 
-  pauseAudio(): Promise<void> {
-    return this.engine.pauseAudio();
+  createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track | null> {
+    return this.engine.createScreenVideoTrack(options);
   }
 
-  resumeAudio(): Promise<void> {
-    return this.engine.resumeAudio();
+  createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track | null> {
+    return this.engine.createScreenAudioTrack(options);
   }
 }