@livedigital/client 3.25.2 → 3.25.3

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

@@ -20,22 +20,16 @@ import {
   MAX_CHECK_RETRIES_BEFORE_CONFIRM,
   SIGNALING_PING_TIMEOUT,
 } from './consts';
+import ChannelStateSynchronizer from '../../ChannelStateSynchronyzer/ChannelStateSynchronizer';
+import { RestoreChannelStateResult } from '../../ChannelStateSynchronyzer/types';
+
+const RESTORE_STATE_RECOMMENDED_INTERVAL = 15_000;
 
 class ChannelStateSyncEventHandler {
   private readonly engine: Engine;
 
   private readonly logger: Logger;
 
-  #confirmedMissingPeers: string[] = [];
-
-  #confirmedMissingConsumers: string[] = [];
-
-  #confirmedMissingProducers: string[] = [];
-
-  #confirmedConsumersWithInconsistentState: string[] = [];
-
-  #confirmedProducersWithInconsistentState: string[] = [];
-
   #checkResults: ChannelStateConsistencyCheckResult[] = [];
 
   #channelStateEventHandling: boolean = false;
@@ -49,13 +43,18 @@ class ChannelStateSyncEventHandler {
     outbound: EXCELLENT_NETWORK_SCORE,
   };
 
+  readonly #channelStateSynchronizer: ChannelStateSynchronizer;
+
+  #lastSyncTime: number = new Date().getTime() - RESTORE_STATE_RECOMMENDED_INTERVAL;
+
   constructor(params: ChannelStateSyncEventHandlerParams) {
     const {
-      engine, onLogMessage, clientEventEmitter, webRTCIssueEmitter,
+      engine, onLogMessage, clientEventEmitter, webRTCIssueEmitter, channelStateSynchronizer,
     } = params;
     this.engine = engine;
     this.clientEventEmitter = clientEventEmitter;
     this.webRTCIssueEmitter = webRTCIssueEmitter;
+    this.#channelStateSynchronizer = channelStateSynchronizer;
     this.logger = new Logger({
       logLevel: engine.logLevel,
       namespace: 'ChannelStateSyncEventHandler',
@@ -70,7 +69,7 @@ class ChannelStateSyncEventHandler {
     try {
       const { event, data } = await this.parseChannelStateSyncEventPayload(payload);
       if (event === 'channel-state' && !this.#channelStateEventHandling) {
-        this.handleChannelStateEvent(data);
+        await this.handleChannelStateEvent(data);
       }
     } catch (error: unknown) {
       this.logger.error('handleChannelStateSyncEvent()', {
@@ -84,9 +83,27 @@ class ChannelStateSyncEventHandler {
     try {
       await this.collectProbableInconsistencyCases(remoteState);
       const confirmedInconsistencyResult = this.getConfirmedInconsistencyResult();
-      if (confirmedInconsistencyResult && confirmedInconsistencyResult.hasInconsistencyCases()) {
-        this.handleConfirmedInconsistencyResult(confirmedInconsistencyResult);
+
+      if (!confirmedInconsistencyResult?.hasInconsistencyCases()) {
+        return;
       }
+
+      if (this.isRestoreStateRequestToEarly()) {
+        this.logger.info('Inconsistency detected, but restore skipped', { ...confirmedInconsistencyResult });
+        return;
+      }
+
+      const restoreResult = await this.#channelStateSynchronizer.restoreState();
+      const updatedCheckResult = this.compareCheckedAndRestoredResults(confirmedInconsistencyResult, restoreResult);
+
+      if (!updatedCheckResult.hasInconsistencyCases()) {
+        this.#checkResults[this.#checkResults.length - 1] = updatedCheckResult;
+        this.logger.info('Inconsistency has been corrected', { ...restoreResult });
+        return;
+      }
+
+      this.logger.warn('Inconsistency was detected', { ...updatedCheckResult });
+      this.handleConfirmedInconsistencyResult(updatedCheckResult);
     } finally {
       this.#channelStateEventHandling = false;
     }
@@ -98,7 +115,6 @@ class ChannelStateSyncEventHandler {
 
   private handleConfirmedInconsistencyResult(confirmedInconsistencyResult: ChannelStateConsistencyCheckResult): void {
     confirmedInconsistencyResult.missingPeers.forEach((peerId) => {
-      this.#confirmedMissingPeers.push(peerId);
       this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelStateInconsistent, {
         peerId,
         type: InconsistenceType.MissingPeer,
@@ -106,7 +122,6 @@ class ChannelStateSyncEventHandler {
     });
 
     confirmedInconsistencyResult.missingProducers.forEach((producerId) => {
-      this.#confirmedMissingProducers.push(producerId);
       this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelStateInconsistent, {
         producerId,
         type: InconsistenceType.MissingProducer,
@@ -114,27 +129,25 @@ class ChannelStateSyncEventHandler {
     });
 
     confirmedInconsistencyResult.producersWithInconsistentState.forEach((producerId) => {
-      this.#confirmedProducersWithInconsistentState.push(producerId);
       this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelStateInconsistent, {
         producerId,
         type: InconsistenceType.IncorrectProducerState,
       });
     });
 
-    if (confirmedInconsistencyResult.missingConsumers.length > 0) {
-      this.#confirmedMissingConsumers.push(...confirmedInconsistencyResult.missingConsumers);
+    confirmedInconsistencyResult.peersWithInconsistentAppData.forEach((peerId) => {
       this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelStateInconsistent, {
-        type: InconsistenceType.MissingConsumers,
+        peerId,
+        type: InconsistenceType.IncorrectAppData,
       });
-    }
+    });
 
-    if (confirmedInconsistencyResult.consumersWithInconsistentState.length > 0) {
-      this.#confirmedConsumersWithInconsistentState
-        .push(...confirmedInconsistencyResult.consumersWithInconsistentState);
+    confirmedInconsistencyResult.consumersWithInconsistentState.forEach((consumerId) => {
       this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelStateInconsistent, {
+        consumerId,
         type: InconsistenceType.IncorrectConsumerState,
       });
-    }
+    });
   }
 
   private getConfirmedInconsistencyResult(): ChannelStateConsistencyCheckResult | undefined {
@@ -145,7 +158,6 @@ class ChannelStateSyncEventHandler {
 
     const confirmedCheckResult = new ChannelStateConsistencyCheckResult({
       missingPeers: this.getConfirmedMissingPeers(lastCheckResult.missingPeers),
-      missingConsumers: this.getConfirmedMissingConsumers(lastCheckResult.missingConsumers),
       missingProducers: this.getConfirmedMissingProducers(lastCheckResult.missingProducers),
       consumersWithInconsistentState: this.getConfirmedConsumersWithInconsistencState(
         lastCheckResult.consumersWithInconsistentState,
@@ -163,7 +175,6 @@ class ChannelStateSyncEventHandler {
     const checker = new ChannelStateConsistencyChecker({
       remoteState,
       localState: this.getLocalState(),
-      ignoreIds: this.getAllConfirmedInconsistentEntityIds(),
     });
 
     const checkResult = checker.check();
@@ -215,14 +226,6 @@ class ChannelStateSyncEventHandler {
     return peerIds.filter((peerId) => this.isReachedMaxCheckRetries('missingPeers', peerId));
   }
 
-  private getConfirmedMissingConsumers(consumersIds: string[]): string[] {
-    return consumersIds.filter((consumerId) => this.isReachedMaxCheckRetries(
-      'missingConsumers',
-      consumerId,
-      1,
-    ));
-  }
-
   private getConfirmedMissingProducers(producerIds: string[]): string[] {
     return producerIds.filter((producerId) => this.isReachedMaxCheckRetries('missingProducers', producerId));
   }
@@ -254,16 +257,6 @@ class ChannelStateSyncEventHandler {
     return JSON.parse(strFromU8(decompressed)) as ChannelStateSyncEventPayload;
   }
 
-  private getAllConfirmedInconsistentEntityIds(): string[] {
-    return [
-      ...this.#confirmedMissingPeers,
-      ...this.#confirmedMissingConsumers,
-      ...this.#confirmedMissingProducers,
-      ...this.#confirmedConsumersWithInconsistentState,
-      ...this.#confirmedProducersWithInconsistentState,
-    ];
-  }
-
   private getLocalState(): ChannelState {
     const { hostPeers } = this.engine;
     return {
@@ -311,6 +304,28 @@ class ChannelStateSyncEventHandler {
     const { inbound, outbound } = this.networkScores;
     return inbound <= BAD_NETWORK_SCORE || outbound <= BAD_NETWORK_SCORE;
   }
+
+  private compareCheckedAndRestoredResults(
+    checkResult: ChannelStateConsistencyCheckResult,
+    restoreResult: RestoreChannelStateResult,
+  ): ChannelStateConsistencyCheckResult {
+    return new ChannelStateConsistencyCheckResult({
+      missingPeers: checkResult.missingPeers
+        .filter((id) => !restoreResult.missingPeers.includes(id)),
+      missingProducers: checkResult.missingProducers
+        .filter((id) => !restoreResult.missingProducers.includes(id)),
+      consumersWithInconsistentState: checkResult.consumersWithInconsistentState
+        .filter((id) => !restoreResult.fixedConsumersState.includes(id)),
+      producersWithInconsistentState: checkResult.producersWithInconsistentState
+        .filter((id) => !restoreResult.fixedProducersState.includes(id)),
+      peersWithInconsistentAppData: checkResult.peersWithInconsistentAppData
+        .filter((id) => !restoreResult.restoredAppDataPeers.includes(id)),
+    });
+  }
+
+  private isRestoreStateRequestToEarly(): boolean {
+    return (new Date().getTime() - this.#lastSyncTime) <= RESTORE_STATE_RECOMMENDED_INTERVAL;
+  }
 }
 
 export default ChannelStateSyncEventHandler;

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

@@ -1,16 +1,21 @@
-/* eslint-disable import/prefer-default-export */
-
 export enum InconsistenceType {
   MissingPeer = 'missing-peer',
-  MissingConsumers = 'missing-consumers',
   MissingProducer = 'missing-producer',
   IncorrectProducerState = 'incorrect-producer-state',
   IncorrectConsumerState = 'incorrect-consumer-state',
+  IncorrectAppData = 'incorrect-app-data',
 }
 
 export type StorageKey = 'missingPeers'
-| 'missingConsumers'
 | 'missingProducers'
 | 'consumersWithInconsistentState'
 | 'producersWithInconsistentState'
 | 'peersWithInconsistentAppData';
+
+export interface ChannelStateConsistencyCheckResultsParams {
+  missingPeers: string[];
+  missingProducers: string[];
+  consumersWithInconsistentState: string[];
+  producersWithInconsistentState: string[];
+  peersWithInconsistentAppData: string[];
+}

package/src/engine/index.ts

@@ -56,7 +56,7 @@ import {
 } from '../types/media';
 import ChannelStateSyncEventHandler from './handlers/ChannelStateSyncEventHandler';
 import { getSupportedCodecsMimeTypes } from '../helpers/media';
-import ChannelStateSynchronizer from './ChannelStateSynchronizer';
+import ChannelStateSynchronizer from './ChannelStateSynchronyzer/ChannelStateSynchronizer';
 import EventsQueue from './EventsQueue';
 import clientMetaProvider from '../ClientMetaProvider';
 
@@ -222,6 +222,7 @@ class Engine {
       webRTCIssueEmitter: this.webRtcIssueDetector?.eventEmitter,
       onLogMessage: params.onLogMessage,
       sendAnalytics: this.#sendAnalytics,
+      channelStateSynchronizer: this.channelStateSynchronizer,
     });
 
     this.handleChannelAudioObserverEvent = (data) => {

package/src/engine/media/tracks/PeerTrack.ts

@@ -169,11 +169,6 @@ class PeerTrack {
         return;
       }
 
-      if (this.#paused) {
-        this.#logger.debug('pause()', { message: 'Already paused', track: this.logCtx, consumer: this.consumer });
-        return;
-      }
-
       await this.pauseConsumer(pauseRemote);
       this.#paused = true;
       this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackPaused, this);
@@ -189,11 +184,6 @@ class PeerTrack {
         return;
       }
 
-      if (!this.#paused) {
-        this.#logger.debug('resume()', { message: 'Already playing', track: this.logCtx });
-        return;
-      }
-
       await this.resumeConsumer(resumeRemote);
       this.#paused = false;
       this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackResumed, this);
@@ -214,11 +204,12 @@ class PeerTrack {
     }
 
     try {
+      this.consumer.resume();
+
       if (resumeRemote) {
         await this.#engine.network.resumeRemoteConsumer(this.consumer.id);
       }
 
-      this.consumer.resume();
       this.checkConsumerState();
       this.#logger.debug('resumeConsumer()', { track: this.logCtx });
     } catch (error) {

package/src/engine/network/Socket.ts

@@ -5,6 +5,7 @@ import { LogLevel, LogMessageHandler, SocketResponse } from '../../types/common'
 import Logger from '../Logger';
 import { SIGNALING_API_VERSION } from '../../constants/common';
 import { MEDIASOUP_MEDIA_ACTIONS_TRACK_EVENTS } from '../../constants/events';
+import RequestError from '../../errors/RequestError';
 
 export type SocketIOConstructorParams = {
   logLevel: LogLevel,
@@ -177,7 +178,7 @@ class SocketIO {
             });
           }
 
-          reject(response.error);
+          reject(new RequestError(response.error, response.errorCode, { ...response }));
         } else {
           if (this.#isBuffering) {
             this.#isBuffering = false;

package/src/engine/network/index.ts

@@ -35,6 +35,7 @@ import Logger from '../Logger';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { SocketIOEvents } from '../../types/socket';
 import { SocketObserverEvent, NetworkObserverEvents } from '../../types/network';
+import RequestError from '../../errors/RequestError';
 
 export type NetworkParams = {
   socketClient: SocketIO;
@@ -252,20 +253,42 @@ class Network {
     }
 
     this.logger.debug('createConsumer()', { producerId });
-    const consumerOptions = await this.socket.request(MEDIASOUP_EVENTS.createConsumer, {
-      producerId,
-      transportId: transport.id,
-      rtpCapabilities,
-      appData: {
-        peerId: this.peerId,
-        appId,
-        channelId,
-      },
-      producerPeerId,
-    }) as RemoteConsumerOptions;
+    let consumerOptions: RemoteConsumerOptions;
+    try {
+      consumerOptions = await this.socket.request<RemoteConsumerOptions>(MEDIASOUP_EVENTS.createConsumer, {
+        producerId,
+        transportId: transport.id,
+        rtpCapabilities,
+        appData: {
+          peerId: this.peerId,
+          appId,
+          channelId,
+        },
+        producerPeerId,
+      });
+    } catch (error) {
+      if (error instanceof RequestError && error.meta?.existedConsumer) {
+        consumerOptions = error.meta.existedConsumer as RemoteConsumerOptions;
+      } else {
+        this.logger.error('Failed to get consumer options', {
+          producerId,
+          rtpCapabilities,
+          appId,
+          channelId,
+          producerPeerId,
+          error: serializeError(error),
+        });
+        throw new Error('Failed to create consumer');
+      }
+    }
 
     const consumer = await transport.consume(consumerOptions);
     const { producerPaused: isProducerPaused } = consumerOptions;
+
+    if (isProducerPaused) {
+      consumer.pause();
+    }
+
     this.logger.debug('Consumer created', { consumerId: consumer.id, label: consumer.appData.label, isProducerPaused });
 
     return {

package/src/errors/LivedigitalSDKError.ts

@@ -1,9 +1,12 @@
 class LivedigitalSDKError extends Error {
   readonly errorCode: string;
 
-  constructor(msg?: string, errorCode?: string) {
+  readonly meta?: Record<string, unknown>;
+
+  constructor(msg?: string, errorCode?: string, meta?: Record<string, unknown>) {
     super(msg);
     this.errorCode = errorCode ?? 'unknown_error';
+    this.meta = meta;
   }
 }
 

package/src/errors/RequestError.ts

@@ -0,0 +1,9 @@
+import LivedigitalSDKError from './LivedigitalSDKError';
+
+class RequestError extends LivedigitalSDKError {
+  constructor(msg?: string, errorCode?: string, meta?: Record<string, unknown>) {
+    super(msg, errorCode ?? 'something_went_wrong', meta);
+  }
+}
+
+export default RequestError;

package/src/types/engine.ts

@@ -26,7 +26,9 @@ import {
   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';
@@ -94,6 +96,7 @@ export interface ChannelStateSyncEventHandlerParams {
   webRTCIssueEmitter?: WebRTCIssueEmitter;
   onLogMessage?: LogMessageHandler;
   sendAnalytics: boolean;
+  channelStateSynchronizer: ChannelStateSynchronizer;
 }
 
 export interface ConnectParams {
@@ -112,6 +115,7 @@ export interface ChannelStateInconsistentPayload {
   type: InconsistenceType;
   peerId?: string;
   producerId?: string;
+  consumerId?: string;
 }
 
 export interface ProducePermissionsChangedPayload {