@livedigital/client 3.50.0 → 3.51.0

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

@@ -0,0 +1,9 @@
+export default abstract class BaseTrackStatsManager {
+    #private;
+    protected constructor({ track }: {
+        track: MediaStreamTrack;
+    });
+    protected abstract cleanupStats(): void;
+    protected touchLastReceivedStatsTimestamp(): void;
+    private startCleanupTimer;
+}

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

@@ -1,16 +1,26 @@
 import type { ParsedInboundVideoStreamStats, ParsedInboundAudioStreamStats } from 'webrtc-issue-detector';
 import type StatsHandler from './StatsHandler';
+import type { ExpectedVideoParams, MOSScores } from '../../qoe/types';
+import type { ScoresCalculator } from '../../qoe/ScoresCalculator';
+import type { WIDStatsAdapter } from '../../qoe/WIDStatsAdapter';
+import BaseTrackStatsManager from './BaseTrackStatsManager';
 interface InboundTrackStatsManagerParams {
     track: MediaStreamTrack;
     statsHandler: StatsHandler;
+    widStatsAdapter: WIDStatsAdapter;
+    scoresCalculator: ScoresCalculator;
+    getExpectedVideoParams?: () => ExpectedVideoParams | undefined;
+    isStaticContent?: boolean;
 }
-export default class InboundTrackStatsManager {
+export default class InboundTrackStatsManager extends BaseTrackStatsManager {
     #private;
-    constructor({ track, statsHandler }: InboundTrackStatsManagerParams);
+    constructor({ track, statsHandler, widStatsAdapter, scoresCalculator, getExpectedVideoParams, isStaticContent, }: InboundTrackStatsManagerParams);
     get videoWebRTCStats(): ParsedInboundVideoStreamStats | undefined;
     get audioWebRTCStats(): ParsedInboundAudioStreamStats | undefined;
+    get scores(): MOSScores;
     private handleWebRTCStats;
     private setVideoWebRTCStats;
     private setAudioWebRTCStats;
+    protected cleanupStats(): void;
 }
 export {};

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

@@ -0,0 +1,25 @@
+import type { ParsedOutboundVideoStreamStats, ParsedOutboundAudioStreamStats } from 'webrtc-issue-detector';
+import type StatsHandler from './StatsHandler';
+import type { MOSScores } from '../../qoe/types';
+import type { ScoresCalculator } from '../../qoe/ScoresCalculator';
+import type { WIDStatsAdapter } from '../../qoe/WIDStatsAdapter';
+import BaseTrackStatsManager from './BaseTrackStatsManager';
+interface OutboundTrackStatsManagerParams {
+    track: MediaStreamTrack;
+    statsHandler: StatsHandler;
+    widStatsAdapter: WIDStatsAdapter;
+    scoresCalculator: ScoresCalculator;
+    isStaticContent?: boolean;
+}
+export default class OutboundTrackStatsManager extends BaseTrackStatsManager {
+    #private;
+    constructor({ track, statsHandler, widStatsAdapter, scoresCalculator, isStaticContent, }: OutboundTrackStatsManagerParams);
+    get videoWebRTCStats(): ParsedOutboundVideoStreamStats | undefined;
+    get audioWebRTCStats(): ParsedOutboundAudioStreamStats | undefined;
+    get scores(): MOSScores;
+    private handleWebRTCStats;
+    private setVideoWebRTCStats;
+    private setAudioWebRTCStats;
+    protected cleanupStats(): void;
+}
+export {};

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

@@ -1,12 +1,13 @@
-import { ParsedConnectionStats, ParsedInboundAudioStreamStats, ParsedInboundVideoStreamStats, ParsedOutboundAudioStreamStats, ParsedOutboundVideoStreamStats, StatsReportItem } from 'webrtc-issue-detector/dist/types';
+import { ParsedConnectionStats, StatsReportItem } from 'webrtc-issue-detector/dist/types';
+import type { ParsedInboundAudioStreamCompositeStats, ParsedInboundVideoStreamCompositeStats, ParsedOutboundAudioStreamCompositeStats, ParsedOutboundVideoStreamCompositeStats } from './types';
 export default class StatsHandler {
     #private;
     handle(payload: StatsReportItem[]): void;
     addConnectionHandler(id: string, handler: (stats: ParsedConnectionStats) => void): void;
-    addInboundVideoHandler(id: string, handler: (stats: ParsedInboundVideoStreamStats) => void): void;
-    addInboundAudioHandler(id: string, handler: (stats: ParsedInboundAudioStreamStats) => void): void;
-    addOutboundVideoHandler(id: string, handler: (stats: ParsedOutboundVideoStreamStats) => void): void;
-    addOutboundAudioHandler(id: string, handler: (stats: ParsedOutboundAudioStreamStats) => void): void;
+    addInboundVideoHandler(id: string, handler: (stats: ParsedInboundVideoStreamCompositeStats) => void): void;
+    addInboundAudioHandler(id: string, handler: (stats: ParsedInboundAudioStreamCompositeStats) => void): void;
+    addOutboundVideoHandler(id: string, handler: (stats: ParsedOutboundVideoStreamCompositeStats[]) => void): void;
+    addOutboundAudioHandler(id: string, handler: (stats: ParsedOutboundAudioStreamCompositeStats) => void): void;
     removeConnectionHandler(id: string): void;
     removeInboundVideoHandler(id: string): void;
     removeInboundAudioHandler(id: string): void;

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

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

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

@@ -1,4 +1,4 @@
-import type { ParsedConnectionStats } from 'webrtc-issue-detector';
+import type { ParsedConnectionStats, ParsedInboundAudioStreamStats, ParsedInboundVideoStreamStats, ParsedOutboundAudioStreamStats, ParsedOutboundVideoStreamStats, ParsedRemoteInboundStreamStats } from 'webrtc-issue-detector';
 import type Media from '../media';
 import type { IPeersService } from '../Peers';
 import type ConnectionStatManager from './ConnectionStatsManager';
@@ -8,10 +8,33 @@ export interface TransportsStatsProviderParams {
     media: Media;
     peers: IPeersService;
 }
-export interface LDTransportWebRTCStats extends ParsedConnectionStats {
+export interface ResultQValues {
+    Qav?: number;
+    Qa?: number;
+    Qv?: number;
+}
+export interface LDTransportWebRTCStats extends ParsedConnectionStats, ResultQValues {
     bitrate: number;
 }
 export interface TransportsWebRTCStats {
     outbound?: LDTransportWebRTCStats;
     inbound?: LDTransportWebRTCStats;
 }
+export interface ParsedInboundVideoStreamCompositeStats {
+    inbound: ParsedInboundVideoStreamStats;
+    connection: ParsedConnectionStats;
+}
+export interface ParsedInboundAudioStreamCompositeStats {
+    inbound: ParsedInboundAudioStreamStats;
+    connection: ParsedConnectionStats;
+}
+export interface ParsedOutboundVideoStreamCompositeStats {
+    remoteInbound: ParsedRemoteInboundStreamStats;
+    outbound: ParsedOutboundVideoStreamStats;
+    connection: ParsedConnectionStats;
+}
+export interface ParsedOutboundAudioStreamCompositeStats {
+    remoteInbound: ParsedRemoteInboundStreamStats;
+    outbound: ParsedOutboundAudioStreamStats;
+    connection: ParsedConnectionStats;
+}

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

@@ -14,6 +14,9 @@ export interface NetworkMetric {
     direction: 'inbound' | 'outbound';
     timestamp: string;
     bitrate: number;
+    Qa?: number;
+    Qv?: number;
+    Qav?: number;
 }
 export interface NetworkMetricsBatch {
     metrics: NetworkMetric[];

package/dist/engine/index.d.ts

@@ -26,6 +26,7 @@ import StatsHandler from './WebRTCStats/StatsHandler';
 import TransportsStatsProvider from './WebRTCStats/TransportsStatsProvider';
 import { TransportsWebRTCStats } from './WebRTCStats/types';
 import PeersStorage from './PeersStorage';
+import { ScoresCalculator } from '../qoe/ScoresCalculator';
 declare class Engine {
     #private;
     private readonly state;
@@ -49,13 +50,15 @@ declare class Engine {
     private readonly statsHandler;
     private readonly transportsStatsProvider;
     private readonly localMutex;
+    private readonly scoresCalculatorInstance;
     private readonly webRtcIssueDetector?;
     private rejoinRequested;
     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, 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);
+    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, scoresCalculatorInstance: ScoresCalculator, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
     get isChannelJoined(): boolean;
+    get scoresCalculator(): ScoresCalculator;
     private initialize;
     release(keepTracks?: boolean): Promise<void>;
     getPeers(): Peer[];

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

@@ -5,6 +5,7 @@ import { type BaseTrackInfo, type EncoderConfig, TrackLabel, type TrackOutboundS
 import type { InternalObserverEvents } from '../../../types/engine';
 import type { BaseTrack, BaseTrackDependenciesParams, BaseTrackParams } from '../../../types/media';
 import type Logger from '../../Logger';
+import type { MOSScores } from '../../../qoe/types';
 type BaseTrackConstructorParams = BaseTrackParams & BaseTrackDependenciesParams;
 export interface LoggerContext {
     label: TrackLabel;
@@ -23,6 +24,7 @@ declare class DefaultBaseTrack implements BaseTrack {
     constructor(params: BaseTrackConstructorParams);
     get videoWebRTCStats(): ParsedOutboundVideoStreamStats | undefined;
     get audioWebRTCStats(): ParsedOutboundAudioStreamStats | undefined;
+    get connectionScores(): MOSScores;
     get logCtx(): LoggerContext;
     get observer(): EnhancedEventEmitter;
     get mediaStreamTrack(): MediaStreamTrack;

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

@@ -10,12 +10,17 @@ import type Network from '../../network';
 import type PeerConsumer from '../../PeerConsumer';
 import type StatsHandler from '../../WebRTCStats/StatsHandler';
 import type Media from '../index';
+import type { MOSScores } from '../../../qoe/types';
+import type { WIDStatsAdapter } from '../../../qoe/WIDStatsAdapter';
+import type { ScoresCalculator } from '../../../qoe/ScoresCalculator';
 export interface PeerTrackDependencies {
     callState: CallState;
     loggerFactory: (namespace: string) => Logger;
     media: Media;
     network: Network;
     peerConsumerFactory: PeerConsumerFactory;
+    widStatsAdapter: WIDStatsAdapter;
+    scoresCalculator: ScoresCalculator;
 }
 interface PeerTrackConstructor extends PeerTrackDependencies {
     mediaStreamTrack: MediaStreamTrack;
@@ -48,6 +53,7 @@ declare class PeerTrack {
     constructor(payload: PeerTrackConstructor);
     get videoWebRTCStats(): ParsedInboundVideoStreamStats | undefined;
     get audioWebRTCStats(): ParsedInboundAudioStreamStats | undefined;
+    get connectionScores(): MOSScores;
     get logCtx(): Record<string, unknown>;
     get volume(): number;
     get isRemote(): boolean;

package/dist/index.d.ts

@@ -7,6 +7,7 @@ import type { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateCustom
 import type { ClientObserverEvents } from './types/engine';
 import type { AudioTrack, Track, VideoTrack } from './types/media';
 import type { IceTransportPolicy } from './engine/signalingApiClient/api';
+import type { ScoresCalculator } from './qoe/ScoresCalculator';
 declare class Client {
     #private;
     private readonly clientEventEmitter;
@@ -18,6 +19,7 @@ declare class Client {
     get availableVideoDevices(): MediaDeviceInfo[];
     get availableAudioDevices(): MediaDeviceInfo[];
     get effectsSDKInitialized(): boolean;
+    get scoresCalculator(): ScoresCalculator;
     detectDevices(force?: boolean): Promise<AvailableMediaDevices>;
     initEffectsSDK(): Promise<boolean>;
     join(params: JoinChannelParams): Promise<void>;
@@ -36,6 +38,7 @@ declare class Client {
     setPreferRelay(value: boolean): void;
     getPreferRelay(): boolean;
     changeIceTransportPolicy(policy: IceTransportPolicy): Promise<void>;
+    restartIce(): Promise<void>;
     transportsStats(): TransportsWebRTCStats | undefined;
     setSignalingServerUrl(url: string): void;
 }