@livedigital/client 3.28.1 → 3.29.0

package/dist/config/ConfigService.d.ts

@@ -1,10 +1,15 @@
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
 import * as client from '../types/client';
 import { InitEffectsSDKParams } from '../types/media';
-declare type ParamsToOmit = 'clientEventEmitter' | 'internalEventEmitter' | 'network' | 'effectsSDKParams';
+declare type ParamsToOmit = 'clientEventEmitter' | 'internalEventEmitter' | 'network' | 'effectsSDKParams' | 'asdk';
 export declare type ProcessedParams = Required<Omit<client.ClientParams, ParamsToOmit>> & {
     loadbalancer: LoadBalancerApiClientParams;
     effectsSDKParams?: InitEffectsSDKParams;
+    asdk: {
+        customerId: string;
+        version: '2.3.5';
+        localDir?: string;
+    };
 };
 export default class ConfigService {
     #private;

package/dist/constants/events.d.ts

@@ -37,6 +37,7 @@ export declare const CLIENT_EVENTS: {
     readonly connectionRestored: "connection-restored";
     readonly forcedDisconnect: "forced-disconnect";
     readonly rejectUnauthorized: "reject-unauthorized";
+    readonly denoiserInitializing: "denoiser-initializing";
 };
 export declare const TRACK_EVENTS: {
     readonly volumeChanged: "volume-changed";

package/dist/constants/events.ts

@@ -38,6 +38,7 @@ export const CLIENT_EVENTS = {
   connectionRestored: 'connection-restored',
   forcedDisconnect: 'forced-disconnect',
   rejectUnauthorized: 'reject-unauthorized',
+  denoiserInitializing: 'denoiser-initializing',
 } as const;
 
 export const TRACK_EVENTS = {

package/dist/engine/IntegrationsService.d.ts

@@ -0,0 +1,28 @@
+import ConfigService from '../config/ConfigService';
+import { AudioTrackProcessorFactory, LoggerFactory } from '../types/container';
+import { ProcessorsCache } from './media/streamEffects/ProcessorsCache';
+export declare type Integrations = 'asdk' | 'rnnoise';
+export declare type IntegrationContext = {
+    integrated: boolean;
+    initPromise: Promise<void>;
+};
+export interface Integration {
+    type: Integrations;
+    enabled: boolean;
+    isInitialized: boolean;
+    waitForInitialization: Promise<void>;
+}
+export declare class IntegrationsService {
+    #private;
+    private readonly config;
+    private readonly processorsCache;
+    private readonly audioTrackProcessorFactory;
+    constructor(config: ConfigService, processorsCache: ProcessorsCache, audioTrackProcessorFactory: AudioTrackProcessorFactory, loggerFactory: LoggerFactory);
+    init(): void;
+    private integrateASDK;
+    get audio(): Integration;
+    private getASDKState;
+    private getRNNoiseState;
+    private integrateRNNoise;
+    reset(): void;
+}

package/dist/engine/index.d.ts

@@ -1,5 +1,6 @@
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
 import WebRTCIssueDetector from 'webrtc-issue-detector';
+import ConfigService from '../config/ConfigService';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role } from '../types/common';
 import type { PeerTrackFactory } from '../types/container';
@@ -10,8 +11,10 @@ import ChannelStateSynchronizer from './ChannelStateSynchronizer/ChannelStateSyn
 import EventsQueue from './EventsQueue';
 import ChannelEventHandler from './handlers/ChannelEventHandler';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
+import { IntegrationsService } from './IntegrationsService';
 import Logger from './Logger';
 import Media from './media';
+import { ProcessorsCache } from './media/streamEffects/ProcessorsCache';
 import VideoTrack from './media/tracks/DefaultVideoTrack';
 import { MyPeer } from './MyPeer';
 import Network from './network';
@@ -25,8 +28,11 @@ import { TransportsWebRTCStats } from './WebRTCStats/types';
 import DataChannelsManager from './network/DataChannelsManager';
 declare class Engine {
     #private;
+    private readonly config;
     private readonly state;
     private readonly myPeer;
+    private readonly integrationsService;
+    private readonly processorsCache;
     private readonly mediaSoupEventsHandler;
     private readonly channelEventsHandler;
     readonly channelStateSynchronizer: ChannelStateSynchronizer;
@@ -45,11 +51,10 @@ declare class Engine {
     private readonly webRtcIssueDetector?;
     private rejoinRequested;
     private isReleasing;
-    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, mediaSoupEventsHandler: MediaSoupEventHandler, channelEventsHandler: ChannelEventHandler, channelStateSynchronizer: ChannelStateSynchronizer, peerTrackFactory: PeerTrackFactory, peers: IPeersService, system: System, media: Media, network: Network, loadBalancerClient: LoadBalancerApiClient, socket: SocketIO, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter, internalEventEmitter: EnhancedEventEmitter, statsHandler: StatsHandler, dataChannelsManager: DataChannelsManager, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
+    constructor(config: ConfigService, state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, mediaSoupEventsHandler: MediaSoupEventHandler, channelEventsHandler: ChannelEventHandler, channelStateSynchronizer: ChannelStateSynchronizer, peerTrackFactory: PeerTrackFactory, peers: IPeersService, system: System, media: Media, network: Network, loadBalancerClient: LoadBalancerApiClient, socket: SocketIO, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter, internalEventEmitter: EnhancedEventEmitter, statsHandler: StatsHandler, dataChannelsManager: DataChannelsManager, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
     get isChannelJoined(): boolean;
     private initialize;
     release(keepTracks?: boolean): Promise<void>;
-    private releaseForRejoin;
     private removeClientEventEmitterListeners;
     getPeers(): Peer[];
     get myPeerId(): string | undefined;
@@ -63,7 +68,6 @@ declare class Engine {
     createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<AudioTrack>;
     createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]>;
     deleteTrack(tracks: BaseTrack): Promise<void>;
-    get canUseNoiseSuppression(): boolean;
     getNodeActiveStreamsStat(): NodeActiveStreamsStat;
     transportsStats(): TransportsWebRTCStats | undefined;
     private connectToSocketServerWithRetry;

package/dist/engine/media/index.d.ts

@@ -1,10 +1,13 @@
 import { Device } from 'mediasoup-client';
 import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
 import ConfigService from '../../config/ConfigService';
-import { CreateCameraVideoTrackOptions, CreateScreenMediaOptions, CreateVideoTrackParams, TrackLabel, TransformParams } from '../../types/common';
+import EnhancedEventEmitter from '../../EnhancedEventEmitter';
+import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, CreateVideoTrackParams, TrackLabel, TransformParams } from '../../types/common';
 import type { AudioTrackFactory, VideoTrackFactory } from '../../types/container';
-import { BaseTrack, InitEffectsSDKParams, TrackWithEncodings } from '../../types/media';
+import { AudioTrack, BaseTrack, InitEffectsSDKParams, TrackWithEncodings } from '../../types/media';
+import { IntegrationsService } from '../IntegrationsService';
 import Logger from '../Logger';
+import { ProcessorsCache } from './streamEffects/ProcessorsCache';
 import EffectsSDKTrackProcessor from './streamEffects/video/esdk/TrackProcessor';
 import MediaStreamTrackManager from './tracks/MediaStreamTrackManager';
 declare class Media {
@@ -12,19 +15,20 @@ declare class Media {
     private readonly config;
     private readonly loggerFactory;
     private readonly audioTrackFactory;
+    private readonly clientEventEmitter;
+    private readonly integrationsService;
+    private readonly processorsCache;
     private readonly videoTrackFactory;
     private readonly mediaStreamTrackManager;
     isDeviceLoaded: boolean;
     private device?;
     private tracks;
-    constructor(config: ConfigService, loggerFactory: (namespace: string) => Logger, audioTrackFactory: AudioTrackFactory, videoTrackFactory: VideoTrackFactory, mediaStreamTrackManager: MediaStreamTrackManager);
+    constructor(config: ConfigService, loggerFactory: (namespace: string) => Logger, audioTrackFactory: AudioTrackFactory, clientEventEmitter: EnhancedEventEmitter, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, videoTrackFactory: VideoTrackFactory, mediaStreamTrackManager: MediaStreamTrackManager);
     get mediasoupDevice(): Device;
-    get isNoiseSuppressorLoaded(): boolean;
     get effectsSDKInitialized(): boolean;
     get effectsSDKParams(): InitEffectsSDKParams | null;
     getTrack(label: TrackLabel): BaseTrack | undefined;
     loadDevice(routerRtpCapabilities: RtpCapabilities): Promise<void>;
-    createNoiseSuppressor(): Promise<void>;
     getTrackCodec(track: TrackWithEncodings): RtpCodecCapability | undefined;
     private createTracks;
     createUserMediaTracks(constraints: MediaStreamConstraints): Promise<BaseTrack[]>;
@@ -36,6 +40,7 @@ declare class Media {
     unpublishTracks(): Promise<void>;
     setTrack(track: BaseTrack): void;
     initEffectsSDK(): Promise<boolean>;
+    initDenoiser(track: AudioTrack, options?: CreateMicrophoneAudioTrackOptions): Promise<void>;
     createEffectsSDKTrackProcessor(trackLabel?: TrackLabel): Promise<EffectsSDKTrackProcessor>;
     static getVideoTrackTransformParams(track: MediaStreamTrack): TransformParams;
     static getScreenVideoTrackParams(options?: CreateScreenMediaOptions): CreateVideoTrackParams;

package/dist/engine/media/streamEffects/ProcessorsCache.d.ts

@@ -0,0 +1,11 @@
+import { TrackLabel } from '../../../types/common';
+import { AudioTrackProcessor } from './audio/AudioTrackProcessor';
+export declare type ProcessorType = 'asdk' | 'rnnoise';
+export declare class ProcessorsCache {
+    #private;
+    add(type: ProcessorType, label: TrackLabel, processor: AudioTrackProcessor): void;
+    get(type: ProcessorType, label: TrackLabel): AudioTrackProcessor | undefined;
+    has(type: ProcessorType, label: TrackLabel): boolean;
+    private getKey;
+    reset(): Promise<void>;
+}

package/dist/engine/media/streamEffects/audio/AudioTrackProcessor.d.ts

@@ -0,0 +1,6 @@
+export interface AudioTrackProcessor {
+    readonly type: 'asdk' | 'rnnoise';
+    processTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;
+    stopProcessing(): Promise<void>;
+    get isProcessing(): boolean;
+}

package/dist/engine/media/streamEffects/audio/asdk/ASDKTrackProcessor.d.ts

@@ -0,0 +1,23 @@
+import { LoggerFactory } from '../../../../../types/container';
+import { AudioTrackProcessor } from '../AudioTrackProcessor';
+import type { atsvb } from './atsrb';
+declare global {
+    interface Window {
+        atsvb: typeof atsvb;
+    }
+}
+export declare type AudioTrackProcessorParams = {
+    esdkCustomerId: string;
+    loggerFactory: LoggerFactory;
+    onModelsLoaded?: () => void;
+};
+export declare class ASDKTrackProcessor implements AudioTrackProcessor {
+    #private;
+    readonly type = "asdk";
+    constructor(params: AudioTrackProcessorParams);
+    init(): Promise<void>;
+    get isProcessing(): boolean;
+    processTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;
+    stopProcessing(): Promise<void>;
+    private atsvbErrorHandler;
+}

package/dist/engine/media/streamEffects/audio/noiseSuppression/{TrackProcessor.d.ts → RNNoiseTrackProcessor.d.ts}

@@ -1,10 +1,12 @@
 import Logger from '../../../../Logger';
+import { AudioTrackProcessor } from '../AudioTrackProcessor';
 interface TrackProcessorParams {
     noiseSuppressor: WebAssembly.WebAssemblyInstantiatedSource;
     loggerFactory: (namespace: string) => Logger;
 }
-export default class TrackProcessor {
+export default class RNNoiseTrackProcessor implements AudioTrackProcessor {
     #private;
+    readonly type = "rnnoise";
     constructor(params: TrackProcessorParams);
     get isProcessing(): boolean;
     processTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;

package/dist/engine/media/tracks/DefaultAudioTrack.d.ts

@@ -1,12 +1,21 @@
 import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
 import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
 import { AudioCodec, AudioEncoderConfig } from '../../../types/common';
+import { AudioTrackProcessorFactory } from '../../../types/container';
+import { ClientObserverEvents } from '../../../types/engine';
 import { AudioTrack, AudioTrackParams, BaseTrackDependenciesParams } from '../../../types/media';
+import { AudioTrackProcessor } from '../streamEffects/audio/AudioTrackProcessor';
 import DefaultBaseTrack from './DefaultBaseTrack';
-declare type AudioTracksConstructorParams = AudioTrackParams & BaseTrackDependenciesParams;
+export declare type AudioTrackDependenciesParams = BaseTrackDependenciesParams & {
+    processorFactory: AudioTrackProcessorFactory;
+    clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>;
+};
+export declare type AudioTracksConstructorParams = AudioTrackParams & AudioTrackDependenciesParams;
 declare class DefaultAudioTrack extends DefaultBaseTrack implements AudioTrack {
     #private;
-    constructor(params: AudioTracksConstructorParams);
+    get isDenoiserRequireActivation(): boolean;
+    prepareTrackProcessor(trackProcessor: AudioTrackProcessor): void;
     get isEffectsProcessing(): boolean;
     getEncoderConfig(): AudioEncoderConfig;
     getEncodings(): RtpEncodingParameters[];

package/dist/helpers/loader.d.ts

@@ -0,0 +1,3 @@
+export declare const asyncLoadScript: (url: string) => Promise<HTMLScriptElement>;
+export declare const loadScriptWithRetries: (url: string, maxRetries?: number, retryDelayMs?: number) => Promise<void>;
+export declare const loadScriptWithFallback: (mainUrl: string, fallbackUrl?: string | undefined) => Promise<void>;