@livedigital/client 3.34.0-createCustomMediaTracks.1 → 3.34.0

package/dist/constants/events.d.ts

@@ -81,7 +81,6 @@ export declare const MEDIASOUP_EVENTS: {
     readonly closeConsumer: "consumer.close";
     readonly pauseConsumer: "consumer.pause";
     readonly resumeConsumer: "consumer.resume";
-    readonly consumerScore: "consumer.score";
     readonly consumerChangePreferredLayers: "consumer.changeConsumerPreferredLayers";
     readonly consumerRequestKeyFrame: "consumer.requestKeyFrame";
     readonly transportCreate: "transport.create";

package/dist/constants/events.ts

@@ -86,7 +86,6 @@ export const MEDIASOUP_EVENTS = {
   closeConsumer: 'consumer.close',
   pauseConsumer: 'consumer.pause',
   resumeConsumer: 'consumer.resume',
-  consumerScore: 'consumer.score',
   consumerChangePreferredLayers: 'consumer.changeConsumerPreferredLayers',
   consumerRequestKeyFrame: 'consumer.requestKeyFrame',
   transportCreate: 'transport.create',

package/dist/engine/Peer.d.ts

@@ -1,6 +1,6 @@
 import { CHANNEL_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS } from '../constants/events';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
-import { ChangePreferredLayersPayload, ConsumerScorePayload, PayloadOfPublishedMedia, PayloadOfUnpublishedMedia, PeerGroup, PeerInfo, PeerShortData, ProducerData, ProducerSetMaxSpatialLayer, Role, SubscribeOptions, TrackLabel, TrackLabelString } from '../types/common';
+import { ChangePreferredLayersPayload, PayloadOfPublishedMedia, PayloadOfUnpublishedMedia, PeerGroup, PeerInfo, PeerShortData, ProducerData, ProducerSetMaxSpatialLayer, Role, SubscribeOptions, TrackLabel, TrackLabelString } from '../types/common';
 import { PeerConsumerFactory } from '../types/container';
 import { GroupsChangedPayload, ProducePermissionsChangedPayload } from '../types/engine';
 import { CallState } from './CallState';
@@ -61,7 +61,6 @@ export declare type PeerObserverEvents = {
     [MEDIASOUP_EVENTS.closeConsumer]: [consumerId: string];
     [MEDIASOUP_EVENTS.pauseConsumer]: [consumerId: string];
     [MEDIASOUP_EVENTS.resumeConsumer]: [consumerId: string];
-    [MEDIASOUP_EVENTS.consumerScore]: [ConsumerScorePayload];
     [MEDIASOUP_EVENTS.consumerChangePreferredLayers]: [ChangePreferredLayersPayload];
     [MEDIASOUP_EVENTS.producerSetMaxSpatialLayer]: [ProducerSetMaxSpatialLayer];
     [CHANNEL_EVENTS.updatePeerAppData]: [Record<string, unknown>];

package/dist/engine/PeerConsumer.d.ts

@@ -10,7 +10,6 @@ export interface PeerConsumerConstructorParams extends PeerConsumerDependencies
 }
 declare class PeerConsumer {
     #private;
-    score: number;
     spatialLayers: number;
     temporalLayers: number;
     currentSpatialLayer: number;

package/dist/engine/PeerProducer.d.ts

@@ -10,7 +10,6 @@ declare class PeerProducer {
     readonly encodings: RtpEncodingParameters[];
     readonly trackTransformParams: TrackTransformParams;
     readonly maxSpatialLayer: number;
-    score: number;
     constructor(params: ProducerData);
 }
 export default PeerProducer;

package/dist/engine/WIDHandler.d.ts

@@ -0,0 +1,21 @@
+import { IssueDetectorResult, NetworkScores } from 'webrtc-issue-detector';
+import AnalyticsApiClient from './analyticsApiClient';
+import type { IPeersService } from './Peers';
+import SocketIO from './network/Socket';
+import { MyPeer } from './MyPeer';
+import type { LoggerFactory } from '../types/container';
+import TransportsStatsProvider from './WebRTCStats/TransportsStatsProvider';
+declare class WIDHandler {
+    #private;
+    private readonly analyticsApiClient;
+    private readonly peers;
+    private readonly socket;
+    private readonly myPeer;
+    private readonly transportsStatsProvider;
+    constructor(analyticsApiClient: AnalyticsApiClient, peers: IPeersService, socket: SocketIO, myPeer: MyPeer, loggerFactory: LoggerFactory, transportsStatsProvider: TransportsStatsProvider);
+    handleIssues(issues: IssueDetectorResult): void;
+    handleNetworkScores(networkScores: NetworkScores): void;
+    private getNodeActiveStreamsStat;
+    private getClientMeta;
+}
+export default WIDHandler;

package/dist/engine/WebRTCStats/TransportsStatsProvider.d.ts

@@ -1,8 +1,12 @@
 import { TransportsStatsProviderParams, TransportsWebRTCStats } from './types';
+import type { LoggerFactory } from '../../types/container';
 export default class TransportsStatsProvider {
     #private;
-    constructor({ sendTransportConnectionManager, receiveTransportConnectionManager, media, peers, }: TransportsStatsProviderParams);
+    constructor(loggerFactory: LoggerFactory);
+    init({ sendTransportConnectionManager, receiveTransportConnectionManager, media, peers, }: TransportsStatsProviderParams): void;
     getStats(): TransportsWebRTCStats;
+    clear(): void;
+    private doGetStats;
     private calculateInboundTracksBitrate;
     private calculateOutboundTracksBitrate;
 }

package/dist/engine/analyticsApiClient/MetricsApi.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+import { NetworkMetricsBatch, WIDMetricsBatch } from './types';
+export default class MetricsApi {
+    private readonly api;
+    constructor(api: AxiosInstance);
+    sendNetworkMetrics(metrics: NetworkMetricsBatch): Promise<void>;
+    sendWIDMetrics(metrics: WIDMetricsBatch): Promise<void>;
+}

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

@@ -1,7 +1,10 @@
 import LogApi from './LogApi';
+import MetricsApi from './MetricsApi';
 export default class AnalyticsApiClient {
     private readonly api;
     private readonly logApi;
+    private readonly metricsApi;
     constructor();
     get log(): LogApi;
+    get metrics(): MetricsApi;
 }

package/dist/engine/analyticsApiClient/types.d.ts

@@ -1,3 +1,4 @@
+import { ClientMetaPayload } from '../../ClientMetaProvider';
 import { LogToRemotePayload } from '../Logger';
 export interface BatchLogPayload {
     logs: LogToRemotePayload[];
@@ -12,11 +13,17 @@ export interface NetworkMetric {
     node: string;
     direction: 'inbound' | 'outbound';
     timestamp: string;
+    bitrate: number;
 }
-export interface SendNetworkMetricsPayload {
+export interface NetworkMetricsBatch {
     metrics: NetworkMetric[];
-    clientMeta: {
-        roomId: string;
+    clientMeta: ClientMetaPayload & {
+        clientUniqueId: string;
+    };
+}
+export interface WIDMetricsBatch {
+    reasons: string[];
+    clientMeta: ClientMetaPayload & {
         clientUniqueId: string;
     };
 }

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

@@ -18,7 +18,6 @@ declare class MediaSoupEventHandler {
     private readonly clientEventEmitter;
     constructor(eventsQueue: EventsQueue, media: Media, network: Network, socket: SocketIO, myPeer: MyPeer, internalEventEmitter: EnhancedEventEmitter, peers: Peers, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
     subscribeToEvents(): void;
-    handleConsumerScoreEvent(payload: string): void;
     private removeEventListeners;
     reset(): void;
     private handleProducerSetMaxSpatialLayer;

package/dist/engine/index.d.ts

@@ -1,10 +1,8 @@
-import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
 import WebRTCIssueDetector from 'webrtc-issue-detector';
 import ConfigService from '../config/ConfigService';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
-import { CreateCameraVideoTrackOptions, CreateCustomMediaOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role } from '../types/common';
+import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role } from '../types/common';
 import type { PeerTrackFactory } from '../types/container';
-import { NodeActiveStreamsStat } from '../types/engine';
 import { AudioTrack, BaseTrack, Track } from '../types/media';
 import { CallState } from './CallState';
 import ChannelStateSynchronizer from './ChannelStateSynchronizer/ChannelStateSynchronizer';
@@ -23,6 +21,7 @@ import SocketIO from './network/Socket';
 import Peer from './Peer';
 import type { IPeersService } from './Peers';
 import System from './system';
+import TransportsStatsProvider from './WebRTCStats/TransportsStatsProvider';
 import StatsHandler from './WebRTCStats/StatsHandler';
 import { TransportsWebRTCStats } from './WebRTCStats/types';
 import DataChannelsManager from './network/DataChannelsManager';
@@ -48,10 +47,11 @@ declare class Engine {
     private readonly internalEventEmitter;
     private readonly statsHandler;
     private readonly dataChannelsManager;
+    private readonly transportsStatsProvider;
     private readonly webRtcIssueDetector?;
     private rejoinRequested;
     private isReleasing;
-    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);
+    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, transportsStatsProvider: TransportsStatsProvider, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
     get isChannelJoined(): boolean;
     private initialize;
     release(keepTracks?: boolean): Promise<void>;
@@ -67,9 +67,7 @@ declare class Engine {
     createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<VideoTrack>;
     createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<AudioTrack>;
     createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]>;
-    createCustomMediaTracks(options?: CreateCustomMediaOptions): Promise<Track[]>;
     deleteTrack(tracks: BaseTrack): Promise<void>;
-    getNodeActiveStreamsStat(): NodeActiveStreamsStat;
     transportsStats(): TransportsWebRTCStats | undefined;
     private connectToSocketServerWithRetry;
     private connectToSocketServer;
@@ -82,7 +80,6 @@ declare class Engine {
     private createSelfPeerTrack;
     private triggerRejoinEventIfAppropriate;
     private watchNetworkState;
-    getAvgTracksScore(kind: MediaKind): number | undefined;
     private watchDocumentUnload;
     private waitForReconnectOrTriggerRejoinEventIfAppropriate;
 }

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

@@ -38,7 +38,6 @@ declare class Media {
     private createTracks;
     createUserMediaTracks(constraints: MediaStreamConstraints): Promise<BaseTrack[]>;
     createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<BaseTrack[]>;
-    createCustomMediaTracks(mediaStream: MediaStream, constraints: MediaStreamConstraints): Promise<BaseTrack[]>;
     deleteTrack(track: BaseTrack): Promise<void>;
     getAllTracks(): BaseTrack[];
     publishedTracks(): BaseTrack[];

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

@@ -56,7 +56,6 @@ declare class PeerTrack {
     get isMuted(): boolean;
     get consumerId(): string | undefined;
     get currentSpatialLayer(): number;
-    get score(): number | undefined;
     close(): Promise<void>;
     mute(): Promise<void>;
     unmute(): Promise<void>;

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

@@ -25,6 +25,5 @@ declare class DataChannelsManager {
     private createAudioObserver;
     private createGeneralDataConsumer;
     private createChannelStateSyncDataConsumer;
-    private createConsumersScoresDataConsumer;
 }
 export default DataChannelsManager;

package/dist/index.d.ts

@@ -2,8 +2,8 @@ import 'reflect-metadata';
 import Peer from './engine/Peer';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
 import { ClientParams } from './types/client';
-import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateCustomMediaOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, Role, TransportsStateInfo } from './types/common';
-import { ClientObserverEvents, NodeActiveStreamsStat } from './types/engine';
+import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, Role, TransportsStateInfo } from './types/common';
+import { ClientObserverEvents } from './types/engine';
 import { AudioTrack, Track, VideoTrack } from './types/media';
 import { TransportsWebRTCStats } from './engine/WebRTCStats/types';
 declare class Client {
@@ -25,15 +25,12 @@ declare class Client {
     createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<VideoTrack>;
     createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<AudioTrack>;
     createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]>;
-    createCustomMediaTracks(options?: CreateCustomMediaOptions): Promise<Track[]>;
     deleteTrack(track: Track): Promise<void>;
     loadPeers(role?: Role): Promise<void>;
     updateAppData(appData: Record<string, unknown>): Promise<void>;
     getTransportsInfo(): Promise<TransportsStateInfo>;
-    getNodeActiveStreamsStat(): NodeActiveStreamsStat;
     setPreferRelay(value: boolean): void;
     getPreferRelay(): boolean;
     transportsStats(): TransportsWebRTCStats | undefined;
-    getAvgTracksScore(kind: 'audio' | 'video'): number | undefined;
 }
 export default Client;