@livedigital/client 2.45.0-test-speaker.1 → 3.0.0

package/src/engine/media/tracks/{AudioTrack.ts → DefaultAudioTrack.ts}

@@ -1,17 +1,14 @@
 import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
 import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
-import { AudioCodec, AudioEncoderConfig, TrackWithEncodings } from '../../../types/common';
-import BaseTrack, { BaseTrackConstructorParams } from './BaseTrack';
+import { AudioCodec, AudioEncoderConfig } from '../../../types/common';
+import DefaultBaseTrack from './DefaultBaseTrack';
 import { INTERNAL_CLIENT_EVENTS } from '../../../constants/events';
 import { AUDIO_ENCODINGS } from '../../../constants/encodings';
 import TrackProcessor from '../streamEffects/audio/noiseSuppression/TrackProcessor';
 import Logger from '../../Logger';
+import { AudioTrack, AudioTrackParams } from '../../../types/media';
 
-interface AudioTrackParams extends BaseTrackConstructorParams {
-  noiseSuppressor?: WebAssembly.WebAssemblyInstantiatedSource;
-}
-
-class AudioTrack extends BaseTrack implements TrackWithEncodings {
+class DefaultAudioTrack extends DefaultBaseTrack implements AudioTrack {
   readonly #trackProcessor?: TrackProcessor;
 
   #originalTrack?: MediaStreamTrack;
@@ -115,4 +112,4 @@ class AudioTrack extends BaseTrack implements TrackWithEncodings {
   }
 }
 
-export default AudioTrack;
+export default DefaultAudioTrack;

package/src/engine/media/tracks/{BaseTrack.ts → DefaultBaseTrack.ts}

@@ -4,7 +4,6 @@ import { Mutex } from 'async-mutex';
 import {
   BaseTrackInfo,
   EncoderConfig,
-  LogLevel,
   SocketResponse, Timeout,
   TrackLabel,
   TrackOutboundStats,
@@ -18,17 +17,9 @@ import { CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, MEDIASOUP_EVENTS } from '../../.
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
 import filterStatsCodecs from '../../../helpers/filterStatsCodecs';
 import MediaStreamTrackManager from './MediaStreamTrackManager';
+import { BaseTrack, BaseTrackParams } from '../../../types/media';
 
-export type BaseTrackConstructorParams = {
-  mediaStreamTrack: MediaStreamTrack,
-  logLevel: LogLevel,
-  engine: Engine,
-  clientEventEmitter: EnhancedEventEmitter,
-  constraints: MediaStreamConstraints;
-  mediaStreamTrackManager: MediaStreamTrackManager;
-};
-
-class BaseTrack {
+class DefaultBaseTrack implements BaseTrack {
   #mediaStreamTrack: MediaStreamTrack;
 
   protected encoderConfig: EncoderConfig = {};
@@ -59,7 +50,7 @@ class BaseTrack {
 
   #mutex = new Mutex();
 
-  constructor(params: BaseTrackConstructorParams) {
+  constructor(params: BaseTrackParams) {
     const {
       mediaStreamTrack, logLevel, engine, clientEventEmitter, constraints, mediaStreamTrackManager,
     } = params;
@@ -385,6 +376,11 @@ class BaseTrack {
     }
   }
 
+  async publish(): Promise<void> {
+    await this.produce({});
+    this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackProduced, this);
+  }
+
   async unpublish(): Promise<void> {
     try {
       if (!this.producer) {
@@ -558,4 +554,4 @@ class BaseTrack {
   }
 }
 
-export default BaseTrack;
+export default DefaultBaseTrack;

package/src/engine/media/tracks/{VideoTrack.ts → DefaultVideoTrack.ts}

@@ -2,24 +2,25 @@ import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
 import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
 import { WEBCAM_SIMULCAST_ENCODINGS } from '../../../constants/encodings';
 import {
-  TrackLabel, TrackPublishParams, TrackWithEncodings, VideoCodec, VideoEncoderConfig,
+  TrackLabel, VideoCodec, VideoEncoderConfig,
 } from '../../../types/common';
-import BaseTrack, { BaseTrackConstructorParams } from './BaseTrack';
+import DefaultBaseTrack from './DefaultBaseTrack';
 import { INTERNAL_CLIENT_EVENTS } from '../../../constants/events';
 import TrackProcessor from '../streamEffects/video/virtual-background/TrackProcessor';
 import {
   BLUR_IN_BACKGROUND_TASK_PIPELINE_CONFIG,
   BLUR_PIPELINE_CONFIG,
 } from '../streamEffects/video/virtual-background/constants';
+import { BaseTrackParams, VideoTrack, VideoTrackPublishParams } from '../../../types/media';
 
-class VideoTrack extends BaseTrack implements TrackWithEncodings {
+class DefaultVideoTrack extends DefaultBaseTrack implements VideoTrack {
   readonly #trackProcessor: TrackProcessor;
 
   #originalTrack?: MediaStreamTrack;
 
   public transformParams = {};
 
-  constructor(params: BaseTrackConstructorParams) {
+  constructor(params: BaseTrackParams) {
     super(params);
     this.#trackProcessor = new TrackProcessor({
       logLevel: params.logLevel,
@@ -124,7 +125,7 @@ class VideoTrack extends BaseTrack implements TrackWithEncodings {
     }
   }
 
-  async publish(params: TrackPublishParams = {}): Promise<void> {
+  async publish(params: VideoTrackPublishParams = {}): Promise<void> {
     await this.produce({
       encodings: this.getEncodings(),
       preferredCodec: this.getPreferredCodec(),
@@ -184,4 +185,4 @@ class VideoTrack extends BaseTrack implements TrackWithEncodings {
   }
 }
 
-export default VideoTrack;
+export default DefaultVideoTrack;

package/src/engine/network/Socket.ts

@@ -50,11 +50,14 @@ class SocketIO {
     return this.connection?.id;
   }
 
-  connect(serverUrl: string): void {
+  connect(serverUrl: string, token: string): void {
     const connection = io(serverUrl, {
       transports: ['polling', 'websocket'],
       upgrade: true,
       rememberUpgrade: false,
+      auth: {
+        token,
+      },
     });
 
     this.connection = connection;
@@ -114,7 +117,7 @@ class SocketIO {
     }
   }
 
-  request(event: string, payload = {}): Promise<SocketResponse> {
+  request<T>(event: string, payload = {}): Promise<SocketResponse<T>> {
     return new Promise((resolve, reject) => {
       if (!this.connection) {
         this.logger.error('request()', { type: event, data: payload });
@@ -122,7 +125,7 @@ class SocketIO {
         return;
       }
 
-      this.connection.emit(event, payload, (response: SocketResponse) => {
+      this.connection.emit(event, payload, (response: SocketResponse<T>) => {
         if (response.error) {
           this.logger.error('request()', { event, payload, response });
           reject(response.error);

package/src/helpers/media.ts

@@ -26,7 +26,7 @@ export const detectHandlerName = (userAgent?: string): types.BuiltinHandlerName
 
 export const getNewAudioContext = (contextOptions?: AudioContextOptions): AudioContext | null => {
   const Context = window.AudioContext // Default
-    || window.webkitAudioContext // Safari and old versions of Chrome
+    || (window as unknown as { webkitAudioContext : any }).webkitAudioContext // Safari and old versions of Chrome
     || false;
 
   if (Context) {

package/src/helpers/retry.ts

@@ -7,6 +7,7 @@ export type RetryOpts = {
   maxBackoffDelayMs?: number;
   actionName?: string; // human-readable action name for debug purposes
   logger?: Logger;
+  abortOnError?: (error: any) => boolean;
 };
 
 const timeProvider = new DefaultTimeProvider();
@@ -36,6 +37,10 @@ const retryAsync = async <ReturnType>(
         });
       }
 
+      if (opts.abortOnError && opts.abortOnError(err)) {
+        throw lastError;
+      }
+
       if (currentAttempt < maxRetries) {
         const delay = 2 ** (currentAttempt - 1) * minBackoffDelayMs;
         // eslint-disable-next-line no-await-in-loop

package/src/index.ts

@@ -7,7 +7,6 @@ import {
   LogLevel,
   LogMessageHandler,
   Role,
-  Track,
   TransportsStateInfo,
 } from './types/common';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
@@ -16,6 +15,8 @@ import Peer from './engine/Peer';
 import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
 import DefaultEngineDependenciesFactory from './engine/DefaultEngineDependenciesFactory';
 import { IssuesHandler, NetworkScoresUpdatedHandler } from './types/engine';
+import DefaultMediaTracksFactory from './engine/media/DefaultMediaTracksFactory';
+import { AudioTrack, Track, VideoTrack } from './types/media';
 
 type ClientParams = {
   observer?: EnhancedEventEmitter;
@@ -47,9 +48,13 @@ class Client {
 
     this._observer = observer ?? new EnhancedEventEmitter();
     const dependenciesFactory = new DefaultEngineDependenciesFactory();
+    const mediaTracksFactory = new DefaultMediaTracksFactory();
     this.engine = new Engine({
       dependenciesFactory,
       clientEventEmitter: this.observer,
+      media: {
+        mediaTracksFactory,
+      },
       network: {
         loadbalancer: {
           baseURL: network?.loadbalancer?.baseURL,
@@ -108,11 +113,11 @@ class Client {
     return this.engine.confirmActivity();
   }
 
-  createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track> {
+  createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<VideoTrack> {
     return this.engine.createCameraVideoTrack(options);
   }
 
-  createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track> {
+  createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<AudioTrack> {
     return this.engine.createMicrophoneAudioTrack(options);
   }
 

package/src/types/common.ts

@@ -8,13 +8,11 @@ import { RtpCapabilities } from 'mediasoup-client/src/RtpParameters';
 import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
 import { ConnectionState } from 'mediasoup-client/src/Transport';
 import { DtlsRole } from 'mediasoup-client/lib/Transport';
-import AudioTrack from '../engine/media/tracks/AudioTrack';
-import VideoTrack from '../engine/media/tracks/VideoTrack';
 import NodeJSTimeout = NodeJS.Timeout;
 
 export type Timeout = NodeJSTimeout | number;
 
-export type SocketResponse = {
+export type SocketResponse<T = Record<string, any>> = T & {
   success?: boolean;
   error?: string;
   errorCode?: string;
@@ -77,10 +75,8 @@ export type AvailableMediaDevices = {
 
 export type JoinChannelParams = {
   channelId: string,
-  appId: string,
-  sdkSecret: string,
+  token: string,
   role: Role,
-  uid?: string,
   appData?: Record<string, unknown>,
 };
 
@@ -176,8 +172,6 @@ export type CreateScreenMediaOptions = BaseVideoTrackOptions & BaseAudioTrackOpt
   audioEncoderConfig?: AudioEncoderConfig,
 };
 
-export type Track = VideoTrack | AudioTrack;
-
 export enum TrackLabel {
   Camera = 'camera',
   Microphone = 'microphone',
@@ -378,10 +372,6 @@ export type CreateTracksPayload = {
   constraints: MediaStreamConstraints,
 };
 
-export type TrackPublishParams = {
-  keyFrameRequestDelay?: number;
-};
-
 export type ChangeProducerStatePayload = {
   peerId: string,
   producerId: string,
@@ -392,11 +382,6 @@ export type ForceCloseProducerPayload = {
   label: TrackLabel,
 };
 
-export interface TrackWithEncodings {
-  getCodecOptions(): ProducerCodecOptions;
-  getEncodings(): RtpEncodingParameters[];
-}
-
 export type ActivityConfirmationRequiredPayload = {
   channelId: string;
   time: number;

package/src/types/engine.ts

@@ -7,8 +7,11 @@ import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { Logger, LogLevel, LogMessageHandler } from './common';
+import {
+  Logger, LogLevel, LogMessageHandler, Role,
+} from './common';
 import ChannelAudioObserverEventHandler from '../engine/handlers/ChannelAudioObserverEventHandler';
+import { MediaTracksFactory } from './media';
 
 export type IssuesHandler = (issues: IssueDetectorResult) => void;
 
@@ -25,6 +28,7 @@ export interface CreateMediaParams {
   logLevel: LogLevel;
   engine: Engine;
   clientEventEmitter: EnhancedEventEmitter;
+  mediaTracksFactory: MediaTracksFactory;
   onLogMessage?: LogMessageHandler;
 }
 
@@ -60,6 +64,12 @@ export interface CreateAudioObserverEventHandlerParams {
   onLogMessage?: LogMessageHandler;
 }
 
+export interface ConnectParams {
+  channelId: string,
+  role: Role,
+  token: string,
+}
+
 export interface EngineDependenciesFactory {
   createSystem: (params: CreateSystemParams) => System;
   createMedia: (params: CreateMediaParams) => Media;

package/src/types/media.ts

@@ -0,0 +1,96 @@
+import { Producer, ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+import { RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import Engine from '../engine';
+import {
+  BaseTrackInfo,
+  EncoderConfig,
+  LogLevel,
+  TrackLabel,
+  TrackOutboundStats,
+  TrackProduceParams,
+} from './common';
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
+import MediaStreamTrackManager from '../engine/media/tracks/MediaStreamTrackManager';
+
+export interface BaseTrackParams {
+  mediaStreamTrack: MediaStreamTrack;
+  logLevel: LogLevel;
+  engine: Engine;
+  clientEventEmitter: EnhancedEventEmitter;
+  constraints: MediaStreamConstraints;
+  mediaStreamTrackManager: MediaStreamTrackManager;
+}
+
+export interface BaseTrack {
+  mediaStreamTrack: MediaStreamTrack;
+  id: string;
+  kind: MediaKind;
+  isPublished: boolean;
+  isPaused: boolean;
+  clientEventEmitter: EnhancedEventEmitter;
+  producerId?: string;
+  getLabel(): TrackLabel;
+  setLabel(label: TrackLabel): void;
+  setEncoderConfig(encoderConfig: EncoderConfig): void;
+  getEncoderConfig(): EncoderConfig;
+  setProducer(producer: Producer): void;
+  setStopTrackOnPause(value: boolean): void;
+  getProducer(): Producer | undefined;
+  stopMediaStreamTrack(): void;
+  closeProducer(stopTrack?: boolean): Promise<void>;
+  setPriority(priority: RTCPriorityType): Promise<void>;
+  produce({
+    encodings,
+    codecOptions,
+    preferredCodec,
+    transformParams,
+    keyFrameRequestDelay,
+  }: TrackProduceParams): Promise<void>;
+  publish(): Promise<void>;
+  unpublish(): Promise<void>;
+  pause(): Promise<void>;
+  resume(): Promise<void>;
+  getInfo(): Promise<BaseTrackInfo>;
+  getStats(): Promise<TrackOutboundStats | undefined>;
+  replaceTrack(track: MediaStreamTrack): Promise<void>
+}
+
+export interface TrackWithEncodings extends BaseTrack {
+  getCodecOptions(): ProducerCodecOptions;
+  getEncodings(): RtpEncodingParameters[];
+  getPreferredCodec(): string;
+}
+
+export interface TrackWithEffects extends BaseTrack {
+  isEffectsProcessing: boolean;
+}
+
+export interface AudioTrack extends BaseTrack, TrackWithEncodings, TrackWithEffects {
+  enableNoiseSuppression(): Promise<void>;
+  disableNoiseSuppression(): Promise<void>;
+}
+
+export type VideoTrackPublishParams = {
+  keyFrameRequestDelay?: number;
+};
+
+export interface VideoTrack extends BaseTrack, TrackWithEncodings, TrackWithEffects {
+  publish(params?: VideoTrackPublishParams): Promise<void>;
+  setTransformParams(transformParams: {}): void;
+  setMaxSpatialLayer(spatialLayer: number): Promise<void>;
+  getMaxSpatialLayer(): number | undefined;
+  enableBlur(): Promise<void>;
+  disableBlur(): Promise<void>;
+}
+
+export type Track = AudioTrack | VideoTrack;
+
+export interface AudioTrackParams extends BaseTrackParams {
+  noiseSuppressor?: WebAssembly.WebAssemblyInstantiatedSource;
+}
+
+export interface MediaTracksFactory {
+  createAudioTrack: (params: AudioTrackParams) => BaseTrack;
+  createVideoTrack: (params: BaseTrackParams) => BaseTrack;
+}

package/src/types/network.ts

@@ -1,3 +1,4 @@
+import { SocketIOEvents } from '../constants/events';
 import { Role } from './common';
 
 export type GetNodeRequest = {
@@ -8,3 +9,26 @@ export type GetNodeRequest = {
 export type GetNodeResponse = {
   webSocketUrl: string;
 };
+
+export type JoinChannelRequest = {
+  appData?: Record<string, unknown>,
+};
+
+export type JoinChannelSuccessResponse = {
+  channelId: string;
+  appId: string;
+  role: string;
+};
+
+export type SocketConnectionError = {
+  message: string;
+  data?: {
+    errorCode: string;
+  };
+};
+
+export type SocketObserverEvent = {
+  state: SocketIOEvents;
+  code?: string;
+  error?: SocketConnectionError;
+};