@livedigital/client 3.48.0 → 3.49.0

package/dist/constants/encodings.d.ts

@@ -1,13 +1,13 @@
-export declare const WEBCAM_SIMULCAST_ENCODINGS: {
+export declare const DEFAULT_WEBCAM_SIMULCAST_ENCODINGS: {
     scaleResolutionDownBy: number;
     maxBitrate: number;
     maxFramerate: number;
 }[];
-export declare const SCREEN_SHARING_SIMULCAST_ENCODINGS: {
+export declare const DEFAULT_SCREEN_MEDIA_SIMULCAST_ENCODINGS: {
     maxBitrate: number;
     dtx: boolean;
 }[];
-export declare const AUDIO_ENCODINGS: {
+export declare const DEFAULT_AUDIO_ENCODINGS: {
     maxBitrate: number;
     dtx: boolean;
 }[];

package/dist/constants/encodings.ts

@@ -1,4 +1,4 @@
-export const WEBCAM_SIMULCAST_ENCODINGS = [
+export const DEFAULT_WEBCAM_SIMULCAST_ENCODINGS = [
   {
     scaleResolutionDownBy: 4, // 320x180 0.15mbps 12fps by default
     maxBitrate: 150000,
@@ -16,11 +16,11 @@ export const WEBCAM_SIMULCAST_ENCODINGS = [
   },
 ];
 
-export const SCREEN_SHARING_SIMULCAST_ENCODINGS = [
+export const DEFAULT_SCREEN_MEDIA_SIMULCAST_ENCODINGS = [
   {
     maxBitrate: 1000000, // 1920x1080 1mbps 30fps by default
     dtx: true,
   },
 ];
 
-export const AUDIO_ENCODINGS = [{ maxBitrate: 40_000, dtx: true }];
+export const DEFAULT_AUDIO_ENCODINGS = [{ maxBitrate: 40_000, dtx: true }];

package/dist/engine/handlers/ChannelAudioObserverEventHandler.d.ts

@@ -1,11 +1,13 @@
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import Logger from '../Logger';
 import PeersStorage from '../PeersStorage';
+import ChannelAudioObserverMissingProducerRestorer from './ChannelAudioObserverMissingProducerRestorer';
 declare class ChannelAudioObserverEventHandler {
     #private;
     private readonly peersStorage;
     private readonly clientEventEmitter;
-    constructor(peersStorage: PeersStorage, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
+    private readonly channelAudioObserverMissingProducerRestorer;
+    constructor(peersStorage: PeersStorage, clientEventEmitter: EnhancedEventEmitter, channelAudioObserverMissingProducerRestorer: ChannelAudioObserverMissingProducerRestorer, loggerFactory: (namespace: string) => Logger);
     handle(data: string): void;
     private handleDominantSpeaker;
     private handlePeerVolumes;

package/dist/engine/handlers/ChannelAudioObserverMissingProducerRestorer.d.ts

@@ -0,0 +1,10 @@
+import type { PeerVolume } from '../../types/channelAudioObserver';
+import Logger from '../Logger';
+import PeersStorage from '../PeersStorage';
+declare class ChannelAudioObserverMissingProducerRestorer {
+    #private;
+    private readonly peersStorage;
+    constructor(peersStorage: PeersStorage, loggerFactory: (namespace: string) => Logger);
+    handlePeerVolume(volume: PeerVolume): void;
+}
+export default ChannelAudioObserverMissingProducerRestorer;

package/dist/engine/handlers/MediaEventHandler.d.ts

@@ -18,7 +18,6 @@ declare class MediaEventHandler {
     private handleProducerMaxSpatialLayerChanged;
     private handleProducerRequestMaxSpatialLayer;
     private handleProducerForciblyClosed;
-    private handleConsumerClosed;
     private handleConsumerResumed;
     private handleConsumerPaused;
     private handleConsumerPreferredLayersChanged;

package/dist/engine/index.d.ts

@@ -16,6 +16,7 @@ import VideoTrack from './media/tracks/DefaultVideoTrack';
 import ProducerCloseManager from './media/producer/ProducerCloseManager';
 import { MyPeer } from './MyPeer';
 import Network from './network';
+import NetworkTransportPolicyManager from './network/NetworkTransportPolicyManager';
 import Peer from './Peer';
 import type { IPeersService } from './Peers';
 import LocalMutex from './LocalMutex';
@@ -24,6 +25,7 @@ import System from './system';
 import StatsHandler from './WebRTCStats/StatsHandler';
 import TransportsStatsProvider from './WebRTCStats/TransportsStatsProvider';
 import { TransportsWebRTCStats } from './WebRTCStats/types';
+import PeersStorage from './PeersStorage';
 declare class Engine {
     #private;
     private readonly state;
@@ -34,9 +36,11 @@ declare class Engine {
     private readonly channelEventsHandler;
     private readonly peerTrackFactory;
     private readonly peers;
+    private readonly peersStorage;
     readonly system: System;
     readonly media: Media;
     readonly network: Network;
+    private readonly networkTransportPolicyManager;
     private readonly producerCloseManager;
     private readonly signalingApiClient;
     private readonly eventsQueue;
@@ -50,11 +54,10 @@ declare class Engine {
     private isReleasing;
     private readonly mark;
     private readonly handleSignalingError;
-    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, mediaEventHandler: MediaEventHandler, channelEventsHandler: ChannelEventHandler, peerTrackFactory: PeerTrackFactory, peers: IPeersService, system: System, media: Media, network: Network, producerCloseManager: ProducerCloseManager, signalingApiClient: SignalingApiClient, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>, statsHandler: StatsHandler, transportsStatsProvider: TransportsStatsProvider, localMutex: LocalMutex, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
+    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, mediaEventHandler: MediaEventHandler, channelEventsHandler: ChannelEventHandler, peerTrackFactory: PeerTrackFactory, peers: IPeersService, peersStorage: PeersStorage, system: System, media: Media, network: Network, networkTransportPolicyManager: NetworkTransportPolicyManager, producerCloseManager: ProducerCloseManager, signalingApiClient: SignalingApiClient, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>, statsHandler: StatsHandler, transportsStatsProvider: TransportsStatsProvider, localMutex: LocalMutex, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
     get isChannelJoined(): boolean;
     private initialize;
     release(keepTracks?: boolean): Promise<void>;
-    private removeClientEventEmitterListeners;
     getPeers(): Peer[];
     get myPeerId(): string | undefined;
     confirmActivity(): Promise<void>;
@@ -70,8 +73,8 @@ declare class Engine {
     deleteTrack(tracks: BaseTrack): Promise<void>;
     transportsStats(): TransportsWebRTCStats | undefined;
     setSignalingServerUrl(url: string): void;
-    private performJoin;
-    private watchClientEvents;
+    private cleanup;
+    private watchInternalEvents;
     private createSelfPeerTrack;
     private triggerRejoinEventIfAppropriate;
     private watchNetworkState;

package/dist/engine/network/DatachannelHeartbeater.d.ts

@@ -1,10 +1,10 @@
 import type { types } from 'mediasoup-client';
-import type { Transport } from 'mediasoup-client/lib/Transport';
 import type { LoggerFactory } from '../../types/container';
+import { LDTransport } from '../../types/mediasoup';
 declare class DatachannelHeartbeater {
     #private;
     constructor(loggerFactory: LoggerFactory);
-    init(transport: Transport, dataProducer: types.DataProducer): void;
+    init(transport: LDTransport, dataProducer: types.DataProducer): void;
     dispose(): void;
     private startHeartbeatInterval;
     private stopHeartbeatInterval;

package/dist/engine/network/NetworkTransportPolicyManager.d.ts

@@ -0,0 +1,22 @@
+import type { TransportDirection } from '../../types/network';
+import Network from './index';
+import { Logger } from '../../types/common';
+declare class NetworkTransportPolicyManager {
+    #private;
+    private readonly network;
+    private readonly loggerFactory;
+    constructor(network: Network, loggerFactory: (namespace: string) => Logger);
+    startMonitoring(): void;
+    stopMonitoring(): void;
+    changeIceTransportPolicy(policy: RTCIceTransportPolicy): Promise<void>;
+    private readonly handleTransportState;
+    private recordDisconnectAndGetCount;
+    private applyRelayPolicy;
+    escalateDirectionToRelay(direction: TransportDirection): Promise<void>;
+    private refreshDirectionRelayState;
+    private getTransportByDirection;
+    private static getPeerConnection;
+    private static getDisconnectsInWindow;
+    private static isDuplicateDisconnect;
+}
+export default NetworkTransportPolicyManager;

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

@@ -1,5 +1,5 @@
 import { Device, type types } from 'mediasoup-client';
-import { IceParameters, Transport } from 'mediasoup-client/lib/Transport';
+import { IceParameters } from 'mediasoup-client/lib/Transport';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { CreateConsumerPayload, CreateConsumerResponse, PeerResponse, Role, TransportsStateInfo, UpdatePeerAppDataPayload } from '../../types/common';
 import { ClientObserverEvents } from '../../types/engine';
@@ -21,10 +21,10 @@ declare class Network {
     private readonly signalingApiClient;
     private readonly datachannelHeartbeater;
     private readonly signalingHeartbeater;
-    sendTransport?: Transport;
-    receiveTransport?: Transport;
+    sendTransport?: LDTransport;
+    receiveTransport?: LDTransport;
     heartbeatDataProducer?: types.DataProducer;
-    signalingTransport?: Transport;
+    signalingTransport?: LDTransport;
     private preferRelay?;
     peersLoaded: boolean;
     constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, dataChannelsManager: DataChannelsManager, signalingApiClient: SignalingApiClient, datachannelHeartbeater: DatachannelHeartbeater, signalingHeartbeater: SignalingHeartbeater);
@@ -40,8 +40,8 @@ declare class Network {
     createSendTransport(mediasoupDevice: Device): Promise<LDTransport>;
     createRecvTransport(mediasoupDevice: Device): Promise<LDTransport>;
     createSignalingTransport(mediasoupDevice: Device): Promise<LDTransport>;
-    getIceParameters(transport: Transport): Promise<IceParameters>;
-    restartIce(transport: Transport): Promise<void>;
+    getIceParameters(transport: LDTransport): Promise<IceParameters>;
+    restartIce(transport: LDTransport): Promise<void>;
     createConsumer({ producerId, rtpCapabilities, appId, channelId, producerPeerId, }: CreateConsumerPayload): Promise<CreateConsumerResponse>;
     initializeHeartbeats(): Promise<void>;
     createKeepAliveConsumer(): Promise<void>;
@@ -68,10 +68,12 @@ declare class Network {
     }>;
     createAllDataChannels(): Promise<void>;
     closeAllDataChannels(): void;
-    waitForReceiveTransportConnected(): Promise<void>;
+    waitForReceiveTransportConnected({ onReceiveTransportFailed, }: {
+        onReceiveTransportFailed: () => Promise<void>;
+    }): Promise<void>;
     triggerChannelStateEvent(peersRole?: Role): Promise<number>;
     waitForChannelMessagesDataConsumerConnected(): Promise<void>;
-    private waitForTransportConnected;
+    private waitForTransportTerminalState;
     private waitForDataConsumerConnected;
     private getParsedTransportStats;
     private logTransportDetails;

package/dist/index.d.ts

@@ -6,6 +6,7 @@ import type { ClientParams } from './types/client';
 import type { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateCustomAudioOptions, CreateCustomVideoOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, Role, TransportsStateInfo } from './types/common';
 import type { ClientObserverEvents } from './types/engine';
 import type { AudioTrack, Track, VideoTrack } from './types/media';
+import type { IceTransportPolicy } from './engine/signalingApiClient/api';
 declare class Client {
     #private;
     private readonly clientEventEmitter;
@@ -34,6 +35,7 @@ declare class Client {
     getTransportsInfo(): Promise<TransportsStateInfo>;
     setPreferRelay(value: boolean): void;
     getPreferRelay(): boolean;
+    changeIceTransportPolicy(policy: IceTransportPolicy): Promise<void>;
     transportsStats(): TransportsWebRTCStats | undefined;
     setSignalingServerUrl(url: string): void;
 }