@livedigital/client 3.42.0-use-webapi-crypto.1 → 3.42.0

package/dist/types/channelStateSyncronizer.d.ts

@@ -1,10 +1,16 @@
 import type { ChannelStateShortPeer } from '../proto/generated/channel/channel_state_short';
+export interface LocalChannelStatePeerProducer {
+    id: string;
+    paused: boolean;
+    stateChangedAt: number;
+}
 export interface LocalChannelStatePeerConsumer {
     id: string;
     paused: boolean;
     producerId: string;
 }
 export interface LocalChannelStatePeer extends ChannelStateShortPeer {
+    producers: LocalChannelStatePeerProducer[];
     consumers?: LocalChannelStatePeerConsumer[];
 }
 export interface LocalChannelState {

package/package.json

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

package/src/constants/common.ts

@@ -2,7 +2,7 @@
 
 import type { LogLevel } from '../types/common';
 
-export const SIGNALING_API_VERSION = 6;
+export const SIGNALING_API_VERSION = 7;
 
 export const LOG_LEVEL_ERROR: LogLevel = 3;
 export const LOG_LEVEL_WARN: LogLevel = 4;

package/src/engine/ChannelStateSynchronizer/ChannelStateSynchronizer.ts

@@ -361,7 +361,7 @@ class ChannelStateSynchronizer {
       const { paused } = clusterPeerProducer;
 
       if (localProducer.paused !== paused) {
-        localProducer.paused = paused;
+        localProducer.setPaused(paused);
         const producerStateEvent = localProducer.paused ? PEER_EVENTS.publisherPaused : PEER_EVENTS.publisherResumed;
         localPeer.observer.safeEmit(producerStateEvent, {
           producerId: localProducer.id,

package/src/engine/PeerProducer.ts

@@ -19,6 +19,8 @@ class PeerProducer {
 
   readonly trackTransformParams?: TrackTransformParams;
 
+  #stateChangedAt: number;
+
   constructor(params: ProducerData) {
     const {
       id, kind, peerId, label, paused,
@@ -32,6 +34,16 @@ class PeerProducer {
     this.encodings = params.encodings;
     this.trackTransformParams = params.trackTransformParams;
     this.maxSpatialLayer = params.maxSpatialLayer;
+    this.#stateChangedAt = Date.now();
+  }
+
+  setPaused(paused: boolean): void {
+    this.paused = paused;
+    this.#stateChangedAt = Date.now();
+  }
+
+  getStateChangedAt(): number {
+    return this.#stateChangedAt;
   }
 }
 

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

@@ -1,18 +1,22 @@
+import { FIVE_SECONDS_IN_MS } from '../../../constants/common';
 import type {
   ChannelStateShort,
-  ChannelStateShortPeer,
-  ChannelStateShortProducer,
 } from '../../../proto/generated/channel/channel_state_short';
-import type { LocalChannelStatePeer, LocalChannelStatePeerConsumer } from '../../../types/channelStateSyncronizer';
+import type {
+  LocalChannelState,
+  LocalChannelStatePeer,
+  LocalChannelStatePeerConsumer,
+  LocalChannelStatePeerProducer,
+} from '../../../types/channelStateSyncronizer';
 import ChannelStateConsistencyCheckResult from './ChannelStateConsistencyCheckResult';
 
 interface ChannelStateConsistencyCheckerParams {
-  localState: ChannelStateShort;
+  localState: LocalChannelState;
   remoteState: ChannelStateShort;
 }
 
 class ChannelStateConsistencyChecker {
-  private readonly localState: ChannelStateShort;
+  private readonly localState: LocalChannelState;
 
   private readonly remoteState: ChannelStateShort;
 
@@ -49,19 +53,15 @@ class ChannelStateConsistencyChecker {
       }
 
       remotePeer.producers.forEach((remoteProducer) => {
-        const localConsumer = this.findLocalConsumerByProducerId(localPeer, remoteProducer.id);
-
-        if (localConsumer && localConsumer.paused !== remoteProducer.paused) {
-          this.consumersWithInconsistentState.push(localConsumer.id);
-        }
-
         const localProducer = this.findLocalProducerById(localPeer, remoteProducer.id);
 
         if (!localProducer) {
           this.missingProducers.push(remoteProducer.id);
+
+          return;
         }
 
-        if (!localProducer) {
+        if (this.isLocalProducerStateChangedRecently(localProducer)) {
           return;
         }
 
@@ -69,6 +69,19 @@ class ChannelStateConsistencyChecker {
 
         if (isInconsistentState) {
           this.producersWithInconsistentState.push(remoteProducer.id);
+
+          // don't check consumer state while producer state is inconsistent
+          return;
+        }
+
+        const localConsumer = this.findLocalConsumerByProducerId(localPeer, remoteProducer.id);
+
+        if (localConsumer && localConsumer.paused !== remoteProducer.paused) {
+          this.consumersWithInconsistentState.push(localConsumer.id);
+        }
+
+        if (!localProducer) {
+          this.missingProducers.push(remoteProducer.id);
         }
       });
     });
@@ -102,7 +115,7 @@ class ChannelStateConsistencyChecker {
     return this.peersWithInconsistentAppData;
   }
 
-  private findLocalPeerById(id: string): ChannelStateShortPeer | undefined {
+  private findLocalPeerById(id: string): LocalChannelStatePeer | undefined {
     return this.localState.peers.find((item) => item.id === id);
   }
 
@@ -113,7 +126,7 @@ class ChannelStateConsistencyChecker {
     return peer.consumers?.find((item) => item.producerId === producerId);
   }
 
-  private findLocalProducerById(peer: ChannelStateShortPeer, id: string): ChannelStateShortProducer | undefined {
+  private findLocalProducerById(peer: LocalChannelStatePeer, id: string): LocalChannelStatePeerProducer | undefined {
     return peer.producers.find((item) => item.id === id);
   }
 
@@ -124,6 +137,10 @@ class ChannelStateConsistencyChecker {
     this.producersWithInconsistentState = [];
     this.peersWithInconsistentAppData = [];
   }
+
+  private isLocalProducerStateChangedRecently(producer: LocalChannelStatePeerProducer): boolean {
+    return Date.now() - producer.stateChangedAt < FIVE_SECONDS_IN_MS;
+  }
 }
 
 export default ChannelStateConsistencyChecker;

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

@@ -274,6 +274,7 @@ class ChannelStateSyncEventHandler {
         producers: peer.getProducers().map((producer) => ({
           id: producer.id,
           paused: producer.paused,
+          stateChangedAt: producer.getStateChangedAt(),
         })),
         consumers: peer.getConsumersState(),
       })),

package/src/engine/handlers/MediaEventHandler.ts

@@ -131,7 +131,7 @@ class MediaEventHandler {
       return;
     }
 
-    producer.paused = true;
+    producer.setPaused(true);
     peer.observer.safeEmit(PEER_EVENTS.publisherPaused, {
       producerId: producer.id,
       kind: producer.kind,
@@ -152,7 +152,7 @@ class MediaEventHandler {
       return;
     }
 
-    producer.paused = false;
+    producer.setPaused(false);
     peer.observer.safeEmit(PEER_EVENTS.publisherResumed, {
       producerId: producer.id,
       kind: producer.kind,

package/src/engine/index.ts

@@ -137,7 +137,7 @@ class Engine {
         this.network.createSendTransport(this.media.mediasoupDevice),
         this.network.createRecvTransport(this.media.mediasoupDevice),
         // @INFO: un-comment to enable signaling tcp transport connection
-        // this.network.createSignalingTransport(this.media.mediasoupDevice),
+        this.network.createSignalingTransport(this.media.mediasoupDevice),
       ]);
 
       this.webRtcIssueDetector?.handleNewPeerConnection(sendTransport.handler._pc, sendTransport.id);
@@ -163,7 +163,7 @@ class Engine {
 
       // @INFO: un-comment to enable signaling tcp transport connection
       // @WARN: must be non-blocking, no await
-      // this.network.createSignalingConsumer();
+      await this.network.createSignalingConsumer();
     } catch (error: unknown) {
       this.#logger.error('initialize()', { error });
 
@@ -888,8 +888,8 @@ class Engine {
       case: 'waitForReconnectOrTriggerRejoinEventIfAppropriate',
     });
 
-    const CHECKS_INTERVAL = 3_000;
-    const REQUIRED_SUCCESSFUL_CHECKS = 4;
+    const CHECKS_INTERVAL = 10_000;
+    const REQUIRED_SUCCESSFUL_CHECKS = 6;
     let continuousNumberOfLoadbalancerSuccessfulChecks = 0;
 
     const checkInterval = setInterval(async () => {

package/src/engine/media/streamEffects/ProcessorsCache.ts

@@ -33,6 +33,7 @@ export class ProcessorsCache {
   reset(): void {
     for (const processor of this.#audioProcessorsCache.values()) {
       processor.stopProcessing();
+      processor.release();
     }
 
     this.#audioProcessorsCache.clear();

package/src/engine/media/streamEffects/audio/AudioTrackProcessor.ts

@@ -3,4 +3,5 @@ export interface AudioTrackProcessor {
   processTrack: (track: MediaStreamTrack) => Promise<MediaStreamTrack>;
   stopProcessing: () => void;
   get isProcessing(): boolean;
+  release: () => void;
 }

package/src/engine/media/streamEffects/audio/asdk/ASDKTrackProcessor.ts

@@ -125,6 +125,11 @@ export class ASDKTrackProcessor implements AudioTrackProcessor {
     await this.#atsvb.preload();
   }
 
+  release(): void {
+    this.#atsvb.stop();
+    this.#atsvb.clear();
+  }
+
   get isProcessing(): boolean {
     return !!this.#track;
   }

package/src/engine/media/streamEffects/audio/noiseSuppression/RNNoiseTrackProcessor.ts

@@ -38,6 +38,10 @@ export default class RNNoiseTrackProcessor implements AudioTrackProcessor {
     return !!this.#track;
   }
 
+  release(): void {
+    this.stopProcessing();
+  }
+
   async processTrack(track: MediaStreamTrack): Promise<MediaStreamTrack> {
     const context = getNewAudioContext();
 

package/src/engine/network/index.ts

@@ -41,11 +41,6 @@ import LivedigitalSDKError from '../../errors/LivedigitalSDKError';
 import { ClientObserverEvents } from '../../types/engine';
 import DataChannelsManager from './DataChannelsManager';
 
-interface IceIntervalTimeouts {
-  send?: ReturnType<typeof setInterval>;
-  recv?: ReturnType<typeof setInterval>;
-}
-
 const TRANSPORT_RESTART_ICE_INTERVAL = 5_000;
 const TRANSPORT_DETAILS_DELAY = 1500;
 
@@ -63,10 +58,7 @@ class Network {
 
   private preferRelay?: boolean;
 
-  readonly #iceIntervalTimeouts: IceIntervalTimeouts = {
-    send: undefined,
-    recv: undefined,
-  };
+  readonly #iceIntervalTimeouts = new Map<string, ReturnType<typeof setInterval>>();
 
   readonly #eventEmitter: EnhancedEventEmitter<NetworkObserverEvents>;
 
@@ -400,7 +392,7 @@ class Network {
     }
 
     this.signalingDataProducer = await transport.produceData({
-      label: 'signaling-data-channel',
+      label: 'heart-beater',
       protocol: 'json',
     });
 
@@ -719,8 +711,7 @@ class Network {
   }
 
   private stopRestartIceAttempts(): void {
-    clearInterval(this.#iceIntervalTimeouts.send);
-    clearInterval(this.#iceIntervalTimeouts.recv);
+    Array.from(this.#iceIntervalTimeouts.values()).forEach((interval) => clearInterval(interval));
   }
 
   private subscribeCommonTransportEvents(transport: Transport): void {
@@ -818,10 +809,10 @@ class Network {
           direction: transport.direction,
         });
 
-        if (this.#iceIntervalTimeouts[transport.direction]) {
+        if (this.#iceIntervalTimeouts.has(transport.id)) {
           this.#logger.debug('Stop receiveTransport.restartIce() retries', { recvTransportId: transport.id });
-          clearInterval(this.#iceIntervalTimeouts[transport.direction]);
-          this.#iceIntervalTimeouts[transport.direction] = undefined;
+          clearInterval(this.#iceIntervalTimeouts.get(transport.id));
+          this.#iceIntervalTimeouts.delete(transport.id);
 
           if (state === 'connected') {
             this.#eventEmitter.safeEmit(NETWORK_OBSERVER_EVENTS.transportState, {
@@ -850,29 +841,38 @@ class Network {
       });
 
       if (['disconnected', 'failed'].includes(state)) {
-        if (this.#iceIntervalTimeouts[transport.direction]) {
+        if (this.#iceIntervalTimeouts.has(transport.id)) {
           return;
         }
 
         if (state === 'failed') {
-          this.#logger.debug(`${ transport.direction }Transport.restartIce()`, { recvTransportId: transport.id });
+          this.#logger.debug(`${ transport.id } transport.restartIce()`, {
+            transportId: transport.id,
+            direction: transport.direction,
+          });
           this.restartIce(transport).catch((error: unknown) => {
             this.#logger.debug('Failed to execute restartIce', {
               error: serializeError(error),
+              transportId: transport.id,
+              direction: transport.direction,
             });
           });
         }
 
-        this.#iceIntervalTimeouts[transport.direction] = setInterval(() => {
+        this.#iceIntervalTimeouts.set(transport.id, setInterval(() => {
           this.restartIce(transport).catch((error: unknown) => {
             this.#logger.debug('Failed to execute restartIce', {
               error: serializeError(error),
+              transportId: transport.id,
+              direction: transport.direction,
             });
           });
-          this.#logger.debug(`${ transport.direction }Transport.restartIce() attempt`, {
+          this.#logger.debug(`${ transport.id } transport.restartIce() attempt`, {
             recvTransportId: transport.id,
+            transportId: transport.id,
+            direction: transport.direction,
           });
-        }, TRANSPORT_RESTART_ICE_INTERVAL);
+        }, TRANSPORT_RESTART_ICE_INTERVAL));
       }
     });
 

package/src/helpers/randomString.ts

@@ -1,7 +1,7 @@
 // eslint-disable-next-line
 const hexLUT: string[] = Array.from({ length: 256 }, (_, i) => (i + 256).toString(16).slice(1));
 
-const RANDOM_STR_LENGTH = 10;
+const RANDOM_STR_LENGTH = 24;
 
 export function randomString(len: number = RANDOM_STR_LENGTH): string {
   const buf = new Uint8Array(len);

package/src/types/channelStateSyncronizer.ts

@@ -1,5 +1,11 @@
 import type { ChannelStateShortPeer } from '../proto/generated/channel/channel_state_short';
 
+export interface LocalChannelStatePeerProducer {
+  id: string;
+  paused: boolean;
+  stateChangedAt: number;
+}
+
 export interface LocalChannelStatePeerConsumer {
   id: string;
   paused: boolean;
@@ -7,6 +13,7 @@ export interface LocalChannelStatePeerConsumer {
 }
 
 export interface LocalChannelStatePeer extends ChannelStateShortPeer {
+  producers: LocalChannelStatePeerProducer[];
   consumers?: LocalChannelStatePeerConsumer[];
 };