@livedigital/client 3.25.2 → 3.25.3

package/dist/types/engine.d.ts

@@ -11,7 +11,7 @@ import { ActivityConfirmationRequiredPayload, AvailableMediaDevices, ChannelEven
 import ChannelAudioObserverEventHandler from '../engine/handlers/ChannelAudioObserverEventHandler';
 import { BaseTrack, MediaTracksFactory, Track, InitEffectsSDKParams } from './media';
 import ChannelStateSyncEventHandler from '../engine/handlers/ChannelStateSyncEventHandler';
-import ChannelStateSynchronizer, { ChannelStateSynchronizerParams } from '../engine/ChannelStateSynchronizer';
+import ChannelStateSynchronizer, { ChannelStateSynchronizerParams } from '../engine/ChannelStateSynchronyzer/ChannelStateSynchronizer';
 import { CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS } from '../constants/events';
 import Peer from '../engine/Peer';
 import { InconsistenceType } from '../engine/handlers/ChannelStateSyncEventHandler/types';
@@ -68,6 +68,7 @@ export interface ChannelStateSyncEventHandlerParams {
     webRTCIssueEmitter?: WebRTCIssueEmitter;
     onLogMessage?: LogMessageHandler;
     sendAnalytics: boolean;
+    channelStateSynchronizer: ChannelStateSynchronizer;
 }
 export interface ConnectParams {
     channelId: string;
@@ -83,6 +84,7 @@ export interface ChannelStateInconsistentPayload {
     type: InconsistenceType;
     peerId?: string;
     producerId?: string;
+    consumerId?: string;
 }
 export interface ProducePermissionsChangedPayload {
     labels: TrackLabel[];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.25.2",
+  "version": "3.25.3",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/{ChannelStateSynchronizer.ts → ChannelStateSynchronyzer/ChannelStateSynchronizer.ts}

@@ -1,18 +1,22 @@
 import { serializeError } from 'serialize-error';
-import Logger from './Logger';
+import Logger from '../Logger';
 import {
   LogLevel, LogMessageHandler, PeerResponse, PeerShortData,
-} from '../types/common';
+} from '../../types/common';
 import {
   CHANNEL_EVENTS, CLIENT_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS,
-} from '../constants/events';
-import Peer from './Peer';
-import { debounce, deepEqualObject } from '../helpers/common';
-import Engine from './index';
-import { InconsistenceType } from './handlers/ChannelStateSyncEventHandler/types';
+} from '../../constants/events';
+import Peer from '../Peer';
+import { debounce, deepEqualObject } from '../../helpers/common';
+import Engine from '../index';
+import {
+  RestoreChannelStateResult,
+  RestoredLocalPeersStateResult,
+  RestoredProducersStateResult,
+  RestoredTracksResult,
+} from './types';
 
 const RESTORE_STATE_DEBOUNCE_TIME_MS = 3000;
-const SYNC_CONSUMERS_DEBOUNCE_TIME_MS = 1000;
 
 export interface ChannelStateSynchronizerParams {
   engine: Engine;
@@ -28,8 +32,6 @@ class ChannelStateSynchronizer {
 
   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) {
@@ -42,86 +44,80 @@ class ChannelStateSynchronizer {
     });
     this.watchNetworkState();
     this.debouncedRestoreState = debounce(this.restoreState.bind(this), RESTORE_STATE_DEBOUNCE_TIME_MS);
-    this.debouncedSyncPeerState = debounce(this.syncPeerState.bind(this), SYNC_CONSUMERS_DEBOUNCE_TIME_MS);
   }
 
   private watchNetworkState(): void {
     this.#engine.clientEventEmitter.on(CLIENT_EVENTS.connectionRestored, async () => {
       await this.debouncedRestoreState();
     });
-
-    this.#engine.clientEventEmitter.on(CLIENT_EVENTS.channelStateInconsistent, async ({ type }) => {
-      if ([InconsistenceType.IncorrectConsumerState, InconsistenceType.MissingConsumers].includes(type)) {
-        await this.debouncedSyncPeerState(type);
-      }
-    });
   }
 
-  private async syncPeerState(type: InconsistenceType): Promise<void> {
+  async restoreState(): Promise<RestoreChannelStateResult> {
+    const result: RestoreChannelStateResult = {
+      missingPeers: [],
+      removedPeers: [],
+      missingProducers: [],
+      removedProducers: [],
+      fixedProducersState: [],
+      fixedConsumersState: [],
+      restoredAppDataPeers: [],
+    };
+
     try {
       if (!this.#engine.isSocketConnectionActive) {
-        this.#logger.info('Connection inactive, skipping re-syncing local peers state', {
-          case: 'restoreLocalState',
-          type,
-        });
-        return;
+        this.#logger.info('Connection inactive, skipping restore local state', { case: 'restoreLocalState' });
+        return result;
       }
 
       this.#engine.eventsQueue.pause();
 
-      this.#logger.info('Re-syncing local peers state', {
-        case: 'restoreLocalState',
-        type,
-      });
+      this.#logger.info('Restoring local state', { case: 'restoreLocalState' });
 
+      const localPeers = this.#engine.hostPeers.map((peer) => peer.shortData);
       const { peers: clusterPeers } = await this.#engine.network.getChannelPeers('host');
-      this.restoreLocalPeersState(clusterPeers);
+
+      const { removedProducers, fixedProducersState } = await this.restoreRemoteProducersState(clusterPeers);
+      result.removedProducers.push(...fixedProducersState);
+      result.removedProducers.push(...removedProducers);
+
+      result.removedPeers.push(...this.removeUnnecessaryPeers(localPeers, clusterPeers));
+      result.missingPeers.push(...this.setMissingPeers(localPeers, clusterPeers));
+
+      const restoreLocalStateResult = this.restoreLocalPeersState(clusterPeers);
+      result.missingProducers.push(...restoreLocalStateResult.missingProducers);
+      result.removedProducers.push(...restoreLocalStateResult.removedProducers);
+      result.restoredAppDataPeers.push(...restoreLocalStateResult.restoredAppDataPeers);
+      result.fixedProducersState.push(...restoreLocalStateResult.fixedProducersState);
+      result.fixedConsumersState.push(...restoreLocalStateResult.fixedConsumersState);
+
+      return result;
     } catch (error) {
-      this.#logger.info('Failed to re-sync local peers state', {
+      this.#logger.info('Failed to restore local state', {
         case: 'restoreLocalState',
-        type,
         error: serializeError(error),
       });
+
+      return result;
     } finally {
       this.#logger.info('Resume events after re-syncing local peers', {
         case: 'restoreLocalState',
-        type,
         accumulatedEventsAmount: this.#engine.eventsQueue.size(),
       });
       this.#engine.eventsQueue.resume();
     }
   }
 
-  private async restoreState(): Promise<void> {
-    try {
-      if (!this.#engine.isSocketConnectionActive) {
-        this.#logger.info('Connection inactive, skipping restore local state', { case: 'restoreLocalState' });
-        return;
-      }
+  private async restoreRemoteProducersState(clusterPeers: PeerResponse[]): Promise<RestoredProducersStateResult> {
+    const results: RestoredProducersStateResult = {
+      removedProducers: [],
+      fixedProducersState: [],
+    };
 
-      this.#logger.info('Restoring local state', { case: 'restoreLocalState' });
-
-      const localPeers = this.#engine.hostPeers.map((peer) => peer.shortData);
-      const { peers: clusterPeers } = await this.#engine.network.getChannelPeers('host');
-
-      await this.restoreRemoteProducersState(clusterPeers);
-      this.removeUnnecessaryPeers(localPeers, clusterPeers);
-      this.setMissingPeers(localPeers, clusterPeers);
-      this.restoreLocalPeersState(clusterPeers);
-    } catch (error) {
-      this.#logger.info('Failed to restore local state', {
-        case: 'restoreLocalState',
-        error: serializeError(error),
-      });
-    }
-  }
-
-  private async restoreRemoteProducersState(clusterPeers: PeerResponse[]): Promise<void> {
     const myLocalPeer = this.#engine.peers.find((peer) => peer.id === this.#engine.myPeerId);
     const myClusterPeer = clusterPeers.find((peer) => peer.id === this.#engine.myPeerId);
 
     if (!myLocalPeer || !myClusterPeer) {
-      return;
+      return results;
     }
 
     // removing extra producers from server
@@ -132,6 +128,7 @@ class ChannelStateSynchronizer {
     await Promise.all(unnecessaryLocalProducers.map(async (producer) => {
       await this.#engine.network.closeRemoteProducer(producer.id);
       myLocalPeer.producers.delete(producer.id);
+      results.removedProducers.push(producer.id);
       this.#logger.info('Unnecessary local producer closed', {
         case: 'restoreLocalState',
         removedProducerId: producer.id,
@@ -144,47 +141,66 @@ class ChannelStateSynchronizer {
       .filter((cp) => !!localTracks.find((track) => track.isPaused && (track.isPaused !== cp.paused)));
     await Promise.all(wrongStateProducers.map(async (producer) => {
       await this.#engine.network.pauseRemoteProducer(producer.id);
+      results.fixedProducersState.push(producer.id);
       this.#logger.info('Remote producer state repaired', {
         case: 'restoreLocalState',
         removedProducerId: producer.id,
         removedProducerPeerId: producer.peerId,
       });
     }));
+
+    return results;
   }
 
-  private removeUnnecessaryPeers(localPeers: PeerShortData[], clusterPeers: PeerResponse[]): void {
+  private removeUnnecessaryPeers(localPeers: PeerShortData[], clusterPeers: PeerResponse[]): string[] {
+    const results: string[] = [];
     const unnecessaryPeers = localPeers
       .filter((localPeer) => !clusterPeers.find((remotePeer) => remotePeer.id === localPeer.id));
 
     unnecessaryPeers.forEach((unnecessaryPeer) => {
       this.#engine.removePeer(unnecessaryPeer.id);
+      results.push(unnecessaryPeer.id);
       this.#logger.info('Unnecessary peer removed', {
         case: 'restoreLocalState',
         removedPeerId: unnecessaryPeer.id,
       });
     });
+
+    return results;
   }
 
-  private setMissingPeers(localPeers: PeerShortData[], clusterPeers: PeerResponse[]): void {
+  private setMissingPeers(localPeers: PeerShortData[], clusterPeers: PeerResponse[]): string[] {
+    const results: string[] = [];
     clusterPeers.forEach((clusterPeer) => {
       const peer = localPeers.find((localPeer) => localPeer.id === clusterPeer.id);
       if (peer) {
         return;
       }
 
-      this.#engine.setPeer(clusterPeer);
+      const newPeer = this.#engine.setPeer(clusterPeer);
+      results.push(newPeer.id);
       this.#logger.info('Missing peer added to storage', {
         case: 'restoreLocalState',
         peerId: clusterPeer.id,
       });
     });
+
+    return results;
   }
 
-  private restoreLocalPeersState(clusterPeers: PeerResponse[]): void {
+  private restoreLocalPeersState(clusterPeers: PeerResponse[]): RestoredLocalPeersStateResult {
     const clusterPeersMap = new Map(clusterPeers.map((peer) => [peer.id, peer]));
-    const actualizedLocalPeers = this.#engine.hostPeers;
+    const localPeers = this.#engine.hostPeers;
+
+    const result: RestoredLocalPeersStateResult = {
+      removedProducers: [],
+      missingProducers: [],
+      restoredAppDataPeers: [],
+      fixedConsumersState: [],
+      fixedProducersState: [],
+    };
 
-    actualizedLocalPeers.forEach((localPeer) => {
+    localPeers.forEach((localPeer) => {
       const clusterPeer = clusterPeersMap.get(localPeer.id);
       if (!clusterPeer) {
         this.#logger.warn('Found new local peer, skip restoring state', {
@@ -195,32 +211,58 @@ class ChannelStateSynchronizer {
         return;
       }
 
-      this.removeUnnecessaryProducers(localPeer, clusterPeer);
-      this.restoreAppData(localPeer, clusterPeer);
-      this.restoreTracksState(localPeer, clusterPeer);
+      result.removedProducers.push(...this.removeUnnecessaryProducers(localPeer, clusterPeer));
+
+      const isAppDataRestored = this.restoreAppData(localPeer, clusterPeer);
+      if (isAppDataRestored) {
+        result.restoredAppDataPeers.push(localPeer.id);
+      }
+
+      const {
+        fixedProducersState,
+        fixedConsumersState,
+        missingProducers,
+      } = this.restoreTracksState(localPeer, clusterPeer);
+
+      result.fixedProducersState.push(...fixedProducersState);
+      result.fixedConsumersState.push(...fixedConsumersState);
+      result.missingProducers.push(...missingProducers);
     });
 
     this.#logger.info('Peers state restored', { case: 'restoreLocalState' });
+
+    return result;
   }
 
-  private removeUnnecessaryProducers(localPeer: Peer, clusterPeer: PeerResponse): void {
+  private removeUnnecessaryProducers(localPeer: Peer, clusterPeer: PeerResponse): string[] {
+    const result: string[] = [];
     const unnecessaryProducers = localPeer.getProducers()
       .filter((lp) => !clusterPeer.producers.find((cp) => cp.id === lp.id));
     unnecessaryProducers.forEach((producer) => {
       localPeer.observer.safeEmit(MEDIASOUP_EVENTS.producerClose, producer);
+      result.push(producer.id);
       this.#logger.info('Unnecessary producer removed', {
         case: 'restoreLocalState',
         removedProducerId: producer.id,
         removedProducerPeerId: producer.peerId,
       });
     });
+
+    return result;
   }
 
-  private restoreTracksState(localPeer: Peer, clusterPeer: PeerResponse): void {
+  private restoreTracksState(localPeer: Peer, clusterPeer: PeerResponse): RestoredTracksResult {
+    const result: RestoredTracksResult = {
+      missingProducers: [],
+      fixedProducersState: [],
+      fixedConsumersState: [],
+    };
+
     clusterPeer.producers.forEach((clusterPeerProducer) => {
       const localProducer = localPeer.producers.get(clusterPeerProducer.id);
       if (!localProducer) {
         localPeer.observer.safeEmit(MEDIASOUP_EVENTS.newProducer, clusterPeerProducer);
+        result.missingProducers.push(clusterPeerProducer.id);
         this.#logger.info('Missing producer added to storage', {
           case: 'restoreLocalState',
           producerId: clusterPeerProducer.id,
@@ -239,6 +281,7 @@ class ChannelStateSynchronizer {
           label: localProducer.label,
           paused: localProducer.paused,
         });
+        result.fixedProducersState.push(clusterPeerProducer.id);
 
         this.#logger.info('Producer state fixed', {
           case: 'restoreLocalState',
@@ -248,10 +291,11 @@ class ChannelStateSynchronizer {
       }
 
       const consumer = localPeer.tracks.get(localProducer.label);
-      if (consumer && consumer.consumerId && consumer.isPaused !== clusterPeerProducer.paused) {
+      if (consumer && consumer.consumerId && consumer.consumer?.paused !== clusterPeerProducer.paused) {
         const { consumerId } = consumer;
         const eventName = localProducer.paused ? MEDIASOUP_EVENTS.pauseConsumer : MEDIASOUP_EVENTS.resumeConsumer;
         localPeer.observer.safeEmit(eventName, consumerId);
+        result.fixedConsumersState.push(consumerId);
         this.#logger.info('Consumer state fixed', {
           case: 'restoreLocalState',
           consumerId,
@@ -260,12 +304,14 @@ class ChannelStateSynchronizer {
         });
       }
     });
+
+    return result;
   }
 
-  private restoreAppData(localPeer: Peer, clusterPeer: PeerResponse): void {
+  private restoreAppData(localPeer: Peer, clusterPeer: PeerResponse): boolean {
     const isSameAppData = deepEqualObject(localPeer.appData, clusterPeer.appData);
     if (isSameAppData) {
-      return;
+      return false;
     }
 
     localPeer.observer.emit(CHANNEL_EVENTS.updatePeerAppData, clusterPeer.appData);
@@ -274,6 +320,8 @@ class ChannelStateSynchronizer {
       peerId: localPeer.id,
       appData: clusterPeer.appData,
     });
+
+    return true;
   }
 }
 

package/src/engine/ChannelStateSynchronyzer/types.ts

@@ -0,0 +1,22 @@
+export interface RestoredProducersStateResult {
+  removedProducers: string[];
+  fixedProducersState: string[];
+}
+
+export interface RestoredTracksResult {
+  missingProducers: string[];
+  fixedProducersState: string[];
+  fixedConsumersState: string[];
+}
+
+export interface RestoredLocalPeersStateResult extends RestoredTracksResult {
+  removedProducers: string[];
+  restoredAppDataPeers: string[];
+}
+
+export type RestoreChannelStateResult = {
+  removedPeers: string[];
+  missingPeers: string[];
+} & RestoredProducersStateResult
+& RestoredTracksResult
+& RestoredLocalPeersStateResult;

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -17,7 +17,9 @@ import SocketIO from './network/Socket';
 import LoadBalancerApiClient from './network/LoadBalancerClient';
 import ChannelAudioObserverEventHandler from './handlers/ChannelAudioObserverEventHandler';
 import ChannelStateSyncEventHandler from './handlers/ChannelStateSyncEventHandler';
-import ChannelStateSynchronizer, { ChannelStateSynchronizerParams } from './ChannelStateSynchronizer';
+import ChannelStateSynchronizer, {
+  ChannelStateSynchronizerParams,
+} from './ChannelStateSynchronyzer/ChannelStateSynchronizer';
 import IssueDetectorFactory from './IssueDetectorFactory';
 
 /* eslint-disable class-methods-use-this */

package/src/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyCheckResult.ts

@@ -1,17 +1,8 @@
-interface ChannelStateConsistencyCheckResultsParams {
-  missingPeers: string[];
-  missingConsumers: string[];
-  missingProducers: string[];
-  consumersWithInconsistentState: string[];
-  producersWithInconsistentState: string[];
-  peersWithInconsistentAppData: string[];
-}
+import { ChannelStateConsistencyCheckResultsParams } from './types';
 
 class ChannelStateConsistencyCheckResult {
   readonly missingPeers: string[];
 
-  readonly missingConsumers: string[];
-
   readonly missingProducers: string[];
 
   readonly consumersWithInconsistentState: string[];
@@ -22,7 +13,6 @@ class ChannelStateConsistencyCheckResult {
 
   constructor(params: ChannelStateConsistencyCheckResultsParams) {
     this.missingPeers = params.missingPeers;
-    this.missingConsumers = params.missingConsumers;
     this.missingProducers = params.missingProducers;
     this.consumersWithInconsistentState = params.consumersWithInconsistentState;
     this.producersWithInconsistentState = params.producersWithInconsistentState;
@@ -31,7 +21,6 @@ class ChannelStateConsistencyCheckResult {
 
   hasInconsistencyCases() {
     return this.missingPeers.length > 0
-      || this.missingConsumers.length > 0
       || this.missingProducers.length > 0
       || this.consumersWithInconsistentState.length > 0
       || this.producersWithInconsistentState.length > 0

package/src/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyChecker.ts

@@ -1,14 +1,9 @@
-import {
-  ChannelState,
-  ChannelStatePeer,
-  ChannelStateProducer,
-} from '../../../types/channelStateSyncronizer';
+import { ChannelState, ChannelStatePeer, ChannelStateProducer } from '../../../types/channelStateSyncronizer';
 import ChannelStateConsistencyCheckResult from './ChannelStateConsistencyCheckResult';
 
 interface ChannelStateConsistencyCheckerParams {
   localState: ChannelState;
   remoteState: ChannelState;
-  ignoreIds: string[];
 }
 
 class ChannelStateConsistencyChecker {
@@ -16,12 +11,8 @@ class ChannelStateConsistencyChecker {
 
   private readonly remoteState: ChannelState;
 
-  private readonly ignoreIds: string[];
-
   private missingPeers: string[] = [];
 
-  private missingConsumers: string[] = [];
-
   private missingProducers: string[] = [];
 
   private consumersWithInconsistentState: string[] = [];
@@ -33,16 +24,11 @@ class ChannelStateConsistencyChecker {
   constructor(params: ChannelStateConsistencyCheckerParams) {
     this.localState = params.localState;
     this.remoteState = params.remoteState;
-    this.ignoreIds = params.ignoreIds;
   }
 
   check(): ChannelStateConsistencyCheckResult {
     this.resetPreviousCheckResults();
     this.remoteState.peers.forEach((remotePeer) => {
-      if (this.ignoreIds.includes(remotePeer.id)) {
-        return;
-      }
-
       const localPeer = this.findLocalPeerById(remotePeer.id);
       if (!localPeer) {
         this.missingPeers.push(remotePeer.id);
@@ -55,16 +41,8 @@ class ChannelStateConsistencyChecker {
       }
 
       remotePeer.producers.forEach((remoteProducer) => {
-        if (this.ignoreIds.includes(remoteProducer.id)) {
-          return;
-        }
-
         const localConsumer = this.findLocalConsumerByProducerId(localPeer, remoteProducer.id);
-        if (
-          localConsumer
-          && !this.ignoreIds.includes(localConsumer.id)
-          && localConsumer.paused !== remoteProducer.paused
-        ) {
+        if (localConsumer && localConsumer.paused !== remoteProducer.paused) {
           this.consumersWithInconsistentState.push(localConsumer.id);
         }
 
@@ -73,10 +51,6 @@ class ChannelStateConsistencyChecker {
           this.missingProducers.push(remoteProducer.id);
         }
 
-        if (!localConsumer && !localProducer) {
-          this.missingConsumers.push(remoteProducer.id);
-        }
-
         if (!localProducer) {
           return;
         }
@@ -88,29 +62,19 @@ class ChannelStateConsistencyChecker {
       });
     });
 
-    const checkResults = new ChannelStateConsistencyCheckResult({
+    return new ChannelStateConsistencyCheckResult({
       missingPeers: this.missingPeers,
-      missingConsumers: this.missingConsumers,
       missingProducers: this.missingProducers,
       consumersWithInconsistentState: this.consumersWithInconsistentState,
       producersWithInconsistentState: this.producersWithInconsistentState,
       peersWithInconsistentAppData: this.peersWithInconsistentAppData,
     });
-
-    return checkResults;
   }
 
   getMissingPeers(): string[] {
     return this.missingPeers;
   }
 
-  /**
-   * Contains list of remote producer ids for which local consumer is missing
-   */
-  getMissingConsumers(): string[] {
-    return this.missingConsumers;
-  }
-
   getMissingProducers(): string[] {
     return this.missingProducers;
   }
@@ -141,7 +105,6 @@ class ChannelStateConsistencyChecker {
 
   private resetPreviousCheckResults(): void {
     this.missingPeers = [];
-    this.missingConsumers = [];
     this.missingProducers = [];
     this.consumersWithInconsistentState = [];
     this.producersWithInconsistentState = [];