@livedigital/client 3.23.1 → 3.24.0

package/dist/engine/ChannelStateSynchronizer.d.ts

@@ -1,5 +1,6 @@
 import { LogLevel, LogMessageHandler } from '../types/common';
 import Engine from './index';
+import { InconsistenceType } from './handlers/ChannelStateSyncEventHandler/types';
 export interface ChannelStateSynchronizerParams {
     engine: Engine;
     logLevel: LogLevel;
@@ -8,9 +9,11 @@ export interface ChannelStateSynchronizerParams {
 }
 declare class ChannelStateSynchronizer {
     #private;
-    readonly debouncedRestoreState: <U>(this: U, ...args: Parameters<() => Promise<void>>) => void;
+    readonly debouncedRestoreState: <U>(this: U, ...args: Parameters<() => Promise<void>>) => void | Promise<void>;
+    readonly debouncedSyncPeerState: <U>(this: U, type: InconsistenceType) => void | Promise<void>;
     constructor({ engine, onLogMessage, logLevel, sendAnalytics, }: ChannelStateSynchronizerParams);
     private watchNetworkState;
+    private syncPeerState;
     private restoreState;
     private restoreRemoteProducersState;
     private removeUnnecessaryPeers;

package/dist/engine/EventsQueue.d.ts

@@ -0,0 +1,26 @@
+/**
+  * Single point of events handling
+  * All events are redirected to that queue
+  * And later flushed to subscribed events handlers
+  *
+  * Has ability to postpone events processing
+  *
+  * When subscribing to event from all places: sockets, data channels
+  * All events should be sent to that queue
+  * And handlers should subscribe to events of that queue
+  */
+import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
+import { Socket } from 'socket.io-client';
+export default class EventsQueue {
+    #private;
+    subscribeToSocket(emmiter: Socket): void;
+    subscribeToDataChannel(dataChannel: DataConsumer): void;
+    on(event: string, handler: (...args: any[]) => void | Promise<void>): void;
+    removeListener(event: string): void;
+    removeAllListeners(events: string[], emitter?: Socket): void;
+    private push;
+    private process;
+    private emit;
+    pause(): void;
+    resume(): void;
+}

package/dist/engine/Peer.d.ts

@@ -88,6 +88,11 @@ declare class Peer {
     removeProducePermission(label: TrackLabelString): Promise<void>;
     getInfo(): Promise<PeerInfo>;
     getProducers(): PeerProducer[];
+    getConsumersState(): {
+        id: string;
+        producerId: string;
+        paused: boolean;
+    }[];
     private handleNewProducer;
     private handlePeerEvents;
     reset(): void;

package/dist/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyCheckResult.d.ts

@@ -1,12 +1,16 @@
 interface ChannelStateConsistencyCheckResultsParams {
     missingPeers: string[];
+    missingConsumers: string[];
     missingProducers: string[];
+    consumersWithInconsistentState: string[];
     producersWithInconsistentState: string[];
     peersWithInconsistentAppData: string[];
 }
 declare class ChannelStateConsistencyCheckResult {
     readonly missingPeers: string[];
+    readonly missingConsumers: string[];
     readonly missingProducers: string[];
+    readonly consumersWithInconsistentState: string[];
     readonly producersWithInconsistentState: string[];
     readonly peersWithInconsistentAppData: string[];
     constructor(params: ChannelStateConsistencyCheckResultsParams);

package/dist/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyChecker.d.ts

@@ -10,16 +10,24 @@ declare class ChannelStateConsistencyChecker {
     private readonly remoteState;
     private readonly ignoreIds;
     private missingPeers;
+    private missingConsumers;
     private missingProducers;
+    private consumersWithInconsistentState;
     private producersWithInconsistentState;
     private peersWithInconsistentAppData;
     constructor(params: ChannelStateConsistencyCheckerParams);
     check(): ChannelStateConsistencyCheckResult;
     getMissingPeers(): string[];
+    /**
+     * Contains list of remote producer ids for which local consumer is missing
+     */
+    getMissingConsumers(): string[];
     getMissingProducers(): string[];
+    getConsumersWithInconsistentState(): string[];
     getProducersWithInconsistentState(): string[];
     getPeersWithInconsistentAppData(): string[];
     private findLocalPeerById;
+    private findLocalConsumerByProducerId;
     private findLocalProducerById;
     private resetPreviousCheckResults;
 }

package/dist/engine/handlers/ChannelStateSyncEventHandler/index.d.ts

@@ -18,7 +18,9 @@ declare class ChannelStateSyncEventHandler {
     private rotateLastProbableInconsistencyCheckResults;
     private isReachedMaxCheckRetries;
     private getConfirmedMissingPeers;
+    private getConfirmedMissingConsumers;
     private getConfirmedMissingProducers;
+    private getConfirmedConsumersWithInconsistencState;
     private getConfirmedProducersWithInconsistencState;
     private getConfirmedPeersWithInconsistentAppData;
     private parseChannelStateSyncEventPayload;

package/dist/engine/handlers/ChannelStateSyncEventHandler/types.d.ts

@@ -1,5 +1,8 @@
 export declare enum InconsistenceType {
     MissingPeer = "missing-peer",
+    MissingConsumers = "missing-consumers",
     MissingProducer = "missing-producer",
-    IncorrectProducerState = "incorrect-producer-state"
+    IncorrectProducerState = "incorrect-producer-state",
+    IncorrectConsumerState = "incorrect-consumer-state"
 }
+export declare type StorageKey = 'missingPeers' | 'missingConsumers' | 'missingProducers' | 'consumersWithInconsistentState' | 'producersWithInconsistentState' | 'peersWithInconsistentAppData';

package/dist/engine/index.d.ts

@@ -9,6 +9,7 @@ import PeerTrack from './media/tracks/PeerTrack';
 import { ClientObserverEvents, EngineDependenciesFactory, InternalObserverEvents, IssuesHandler, NetworkScoresUpdatedHandler, NodeActiveStreamsStat } from '../types/engine';
 import { LoadBalancerApiClientParams } from './network/LoadBalancerClient';
 import { AudioTrack, BaseTrack, InitEffectsSDKParams, MediaTracksFactory, Track } from '../types/media';
+import EventsQueue from './EventsQueue';
 declare type EngineParams = {
     clientEventEmitter: EnhancedEventEmitter;
     internalEventEmitter: EnhancedEventEmitter;
@@ -34,6 +35,7 @@ declare class Engine {
     media: Media;
     clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>;
     internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>;
+    eventsQueue: EventsQueue;
     logLevel: LogLevel;
     readonly peersRepository: Map<string, Peer>;
     private channelEventsHandler;