@livedigital/client 3.48.0 → 3.49.1

package/src/engine/EventsQueue.ts

@@ -1,255 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
-import { serializeError } from 'serialize-error';
-import { Logger } from '../types/common';
-import { TOKEN } from '../inversify.tokens';
-import { ChannelMessage } from '../proto/generated/channel_message/channel_message';
-import { ChannelEvent, channelEventTypeToJSON } from '../proto/generated/channel_message/channel_event';
-import { MediaEvent, mediaEventTypeToJSON } from '../proto/generated/channel_message/media_event';
-
-interface PendingMessage {
-  total: number;
-  received: Uint8Array[];
-  msgId: number;
-}
-
-const CHUNK_HEADER_SIZE = 12;
-const CHUNK_HEADER_MSG_ID_OFFSET = 0;
-const CHUNK_HEADER_INDEX_OFFSET = 4;
-const CHUNK_HEADER_TOTAL_OFFSET = 8;
-
-@injectable()
-export default class EventsQueue {
-  readonly #queue: ChannelMessage[] = [];
-
-  #paused = false;
-
-  #processing = false;
-
-  #mediaEventHandler?: (event: MediaEvent) => void | Promise<void>;
-
-  #channelEventHandler?: (event: ChannelEvent) => void | Promise<void>;
-
-  readonly #pendingMessagesBuffer = new Map<number, PendingMessage>();
-  readonly #logger: Logger;
-
-  #processedMessageIds: Set<number> = new Set<number>();
-
-  constructor(@inject(TOKEN.LoggerFactory) loggerFactory: (namespace: string) => Logger) {
-    this.#logger = loggerFactory('EventsQueue');
-  }
-
-  setMediaEventHandler(handler: (event: MediaEvent) => void | Promise<void>): void {
-    this.#mediaEventHandler = handler;
-    this.#logger.info('Media event handler set', {
-      case: 'EventsQueue',
-    });
-  }
-
-  setChannelEventHandler(handler: (event: ChannelEvent) => void | Promise<void>): void {
-    this.#channelEventHandler = handler;
-    this.#logger.info('Channel event handler set', {
-      case: 'EventsQueue',
-    });
-  }
-
-  subscribe(dataChannel: DataConsumer): void {
-    this.#processedMessageIds = new Set<number>();
-    let lastReceivedMsgId = 0;
-
-    const onMessage = (raw: ArrayBuffer): void => {
-      try {
-        const pendingMessage = this.processMessageChunk(raw);
-
-        if (!pendingMessage || !this.isPendingMessageFullyReceived(pendingMessage)) {
-          return;
-        }
-
-        const fullBytes = this.finalizeMessageBytes(pendingMessage);
-        const message = ChannelMessage.decode(fullBytes);
-
-        if (message.id) {
-          if (this.#processedMessageIds.has(message.id)) {
-            this.#logger.warn('Received duplicate message', {
-              case: 'EventsQueue',
-              lastReceivedMsgId,
-              currentReceivedMsgId: message.id,
-            });
-          }
-
-          if (message.id > lastReceivedMsgId + 1) {
-            this.#logger.warn('Received out of order message', {
-              case: 'EventsQueue',
-              lastReceivedMsgId,
-              currentReceivedMsgId: message.id,
-            });
-          }
-        }
-
-        this.#processedMessageIds.add(message.id);
-        lastReceivedMsgId = message.id;
-        this.push(message);
-      } catch (e) {
-        this.#logger.error('Failed to parse channel message', {
-          error: serializeError(e),
-          case: 'EventsQueue',
-        });
-      }
-    };
-
-    const onClose = (): void => {
-      dataChannel.removeListener('message', onMessage);
-      dataChannel.removeListener('close', onClose);
-    };
-
-    dataChannel.on('close', onClose);
-    dataChannel.on('message', onMessage);
-
-    this.#logger.info('Subscribed to data channel', {
-      case: 'EventsQueue',
-    });
-  }
-
-  private push(message: ChannelMessage): void {
-    this.#queue.push(message);
-    void this.process();
-  }
-
-  private async process(): Promise<void> {
-    if (this.#paused || this.#processing) {
-      return;
-    }
-
-    this.#processing = true;
-
-    while (!this.#paused && this.#queue.length > 0) {
-      const message = this.#queue.shift();
-
-      if (!message) {
-        continue;
-      }
-
-      try {
-        if (message.channelEvent && this.#channelEventHandler) {
-          this.#logger.debug('Handle channel event', {
-            case: 'EventsQueue',
-            id: message.id,
-            type: channelEventTypeToJSON(message.channelEvent.eventType),
-            event: message.channelEvent,
-          });
-
-          await this.#channelEventHandler(message.channelEvent);
-          continue;
-        }
-
-        if (message.mediaEvent && this.#mediaEventHandler) {
-          this.#logger.debug('Handle media event', {
-            case: 'EventsQueue',
-            id: message.id,
-            type: mediaEventTypeToJSON(message.mediaEvent.eventType),
-            event: message.mediaEvent,
-          });
-
-          await this.#mediaEventHandler(message.mediaEvent);
-          continue;
-        }
-
-        this.#logger.warn('Received unknown message', { message, case: 'EventsQueue' });
-      } catch (error) {
-        this.#logger.error('Failed to handle event', {
-          case: 'EventsQueue',
-          id: message.id,
-          error: serializeError(error),
-        });
-      }
-    }
-
-    this.#processing = false;
-
-    // If new events were pushed during processing, process again
-    if (!this.#paused && this.#queue.length > 0) {
-      queueMicrotask(() => void this.process());
-    }
-  }
-
-  private processMessageChunk(data: ArrayBuffer): PendingMessage | undefined {
-    const bytes = new Uint8Array(data);
-
-    if (bytes.length < CHUNK_HEADER_SIZE) {
-      this.#logger.warn('Chunk too small', {
-        case: 'EventsQueue',
-        bytesLength: bytes.length,
-      });
-
-      return;
-    }
-
-    const { msgId, index, total } = this.parseMessageChunkHeader(bytes);
-    const dataPart = bytes.slice(CHUNK_HEADER_SIZE);
-
-    if (!this.#pendingMessagesBuffer.has(msgId)) {
-      this.#pendingMessagesBuffer.set(msgId, { msgId, total, received: [] });
-    }
-
-    const entry: PendingMessage | undefined = this.#pendingMessagesBuffer.get(msgId);
-
-    if (!entry) {
-      this.#logger.warn('Chunk buffer entry not found for msgId', {
-        msgId,
-        case: 'EventsQueue',
-      });
-
-      return;
-    }
-
-    entry.received[index] = dataPart;
-    entry.msgId = msgId;
-
-    return entry;
-  }
-
-  private parseMessageChunkHeader(bytes: Uint8Array): { msgId: number; index: number; total: number } {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-
-    return {
-      msgId: view.getUint32(CHUNK_HEADER_MSG_ID_OFFSET),
-      index: view.getUint32(CHUNK_HEADER_INDEX_OFFSET),
-      total: view.getUint32(CHUNK_HEADER_TOTAL_OFFSET),
-    };
-  }
-
-  private isPendingMessageFullyReceived(pendingMessage: PendingMessage): boolean {
-    return pendingMessage.received.filter(Boolean).length === pendingMessage.total;
-  }
-
-  private finalizeMessageBytes(entry: PendingMessage): Uint8Array {
-    const fullBytes = new Uint8Array(entry.received.reduce((sum, arr) => sum + arr.length, 0));
-    let offset = 0;
-
-    for (const chunk of entry.received) {
-      fullBytes.set(chunk, offset);
-      offset += chunk.length;
-    }
-
-    this.#pendingMessagesBuffer.delete(entry.msgId);
-
-    return fullBytes;
-  }
-
-  pause(): void {
-    this.#paused = true;
-  }
-
-  size(): number {
-    return this.#queue.length;
-  }
-
-  resume(): void {
-    this.#paused = false;
-    void this.process();
-  }
-
-  isMessageReceived(messageId: number): boolean {
-    return this.#processedMessageIds.has(messageId);
-  }
-}

package/src/engine/IntegrationsService.ts

@@ -1,163 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { URL } from 'url';
-import ConfigService from '../config/ConfigService';
-import { loadScriptWithFallback } from '../helpers/loader';
-import { TOKEN } from '../inversify.tokens';
-import { TrackLabel } from '../types/common';
-import type { AudioTrackProcessorFactory, LoggerFactory } from '../types/container';
-import Logger from './Logger';
-import { ASDKTrackProcessor } from './media/streamEffects/audio/asdk/ASDKTrackProcessor';
-import { compileWASMModule } from './media/streamEffects/audio/noiseSuppression/WasmModuleCompiler';
-import { ProcessorsCache } from './media/streamEffects/ProcessorsCache';
-
-export type Integrations = 'asdk' | 'rnnoise'; // later 'esdk' should be added
-export interface IntegrationContext {
-  integrated: boolean;
-  initPromise: Promise<void>;
-}
-
-export interface Integration {
-  type: Integrations;
-  enabled: boolean; // flag to show that integration is requested/enabled through ClientParams
-  isInitialized: boolean;
-  waitForInitialization: Promise<void>;
-}
-
-@injectable()
-export class IntegrationsService {
-  readonly #integrationsStorage = new Map<Integrations, IntegrationContext>();
-
-  readonly #logger: Logger;
-
-  constructor(
-    @inject(TOKEN.Config) private readonly config: ConfigService,
-    @inject(TOKEN.ProcessorsCache) private readonly processorsCache: ProcessorsCache,
-    @inject(TOKEN.AudioTrackProcessorFactory) private readonly audioTrackProcessorFactory: AudioTrackProcessorFactory,
-    @inject(TOKEN.LoggerFactory) loggerFactory: LoggerFactory,
-  ) {
-    this.#logger = loggerFactory('IntegrationsService');
-  }
-
-  init(): void { // must not be async
-    const denoiser = this.config.get('denoiser');
-
-    if (denoiser === 'asdk') {
-      this.#logger.info('Start integration of ASDK', {
-        denoiser,
-      });
-
-      const context: IntegrationContext = {
-        integrated: false,
-        initPromise: this.integrateASDK(),
-      };
-
-      this.#integrationsStorage.set('asdk', context);
-    } else {
-      this.#logger.info('Start integration of RNNoise', {
-        denoiser,
-      });
-
-      const context: IntegrationContext = {
-        integrated: false,
-        initPromise: this.integrateRNNoise(),
-      };
-
-      this.#integrationsStorage.set('rnnoise', context);
-    }
-  }
-
-  private async integrateASDK(): Promise<void> {
-    const asdkParams = this.config.get('asdk');
-    const staticFilesPath = this.config.get('staticFilesPath');
-
-    if (!window.atsvb) {
-      const remoteUrl = `https://effectssdk.ai/sdk/audio/dev/${ asdkParams.version }/atsvb-web.js`;
-      let localUrl = remoteUrl;
-
-      if (asdkParams.localDir) {
-        const localPath = `${ asdkParams.localDir }/${ asdkParams.version }/atsvb-web.js`;
-        const url = new URL(localPath, staticFilesPath);
-        localUrl = url.href;
-      }
-
-      await loadScriptWithFallback(localUrl, remoteUrl);
-    }
-
-    if (!window.atsvb) {
-      this.#logger.info('Audio Effects SDK is not loaded, skipping initialization', { case: 'initAudioSDK' });
-
-      throw new Error('windows.atsvb is still missing');
-    }
-
-    const processor = this.audioTrackProcessorFactory({
-      trackLabel: TrackLabel.Microphone,
-    }) as ASDKTrackProcessor;
-
-    await processor.init();
-
-    this.processorsCache.add('asdk', TrackLabel.Microphone, processor);
-
-    const context = this.#integrationsStorage.get('asdk');
-
-    if (!context) {
-      throw Error('IntegrationContext is missing for ASDK');
-    }
-
-    context.integrated = true;
-  }
-
-  get audio(): Integration {
-    const denoiser = this.config.get('denoiser');
-
-    if (denoiser === 'asdk') {
-      return this.getASDKState();
-    }
-
-    return this.getRNNoiseState();
-  }
-
-  private getASDKState(): Integration {
-    const asdk = this.#integrationsStorage.get('asdk');
-
-    return {
-      type: 'asdk',
-      enabled: Boolean(asdk),
-      isInitialized: asdk?.integrated ?? false,
-      waitForInitialization: asdk?.initPromise ?? Promise.resolve(),
-    };
-  }
-
-  private getRNNoiseState(): Integration {
-    const rnnoise = this.#integrationsStorage.get('rnnoise');
-
-    return {
-      type: 'rnnoise',
-      enabled: Boolean(rnnoise),
-      isInitialized: rnnoise?.integrated ?? false,
-      waitForInitialization: rnnoise?.initPromise ?? Promise.resolve(),
-    };
-  }
-
-  private async integrateRNNoise(): Promise<void> {
-    const noiseSuppressor = await compileWASMModule(this.config.get('staticFilesPath'));
-
-    const processor = this.audioTrackProcessorFactory({
-      trackLabel: TrackLabel.Microphone,
-      noiseSuppressor,
-    });
-
-    this.processorsCache.add('rnnoise', TrackLabel.Microphone, processor);
-
-    const context = this.#integrationsStorage.get('rnnoise');
-
-    if (!context) {
-      throw Error('IntegrationContext is missing for RNNoise');
-    }
-
-    context.integrated = true;
-  }
-
-  reset(): void {
-    this.#integrationsStorage.clear();
-  }
-}

package/src/engine/LocalMutex.ts

@@ -1,45 +0,0 @@
-import { Mutex } from 'async-mutex';
-import { injectable } from 'inversify';
-import { MutexKey } from '../constants/mutex';
-
-@injectable()
-export default class LocalMutex {
-  readonly #mutexMap = new Map<MutexKey, Mutex>();
-
-  async lock(key: MutexKey): Promise<() => void> {
-    let mutex = this.#mutexMap.get(key);
-
-    if (!mutex) {
-      mutex = new Mutex();
-      this.#mutexMap.set(key, mutex);
-    }
-
-    if (mutex.isLocked()) {
-      await mutex.waitForUnlock();
-    }
-
-    return await mutex.acquire();
-  }
-
-  isLocked(key: MutexKey): boolean {
-    const mutex = this.#mutexMap.get(key);
-
-    if (mutex) {
-      return mutex.isLocked();
-    }
-
-    return false;
-  }
-
-  async waitForUnlock(key: MutexKey): Promise<void> {
-    const mutex = this.#mutexMap.get(key);
-
-    if (mutex?.isLocked()) {
-      await mutex.waitForUnlock();
-
-      return;
-    }
-
-    await Promise.resolve();
-  }
-}

package/src/engine/Logger.ts

@@ -1,234 +0,0 @@
-import debug from 'debug';
-import { MessageBatcher } from 'message-batcher';
-import { serializeError } from 'serialize-error';
-import clientMetaProvider from '../ClientMetaProvider';
-import { HALF_SECOND_IN_MS, LogLevels, SECOND_IN_MS } from '../constants/common';
-import { isObject } from '../helpers/common';
-import type { LogLevel, LogLevelStr, LogMessageHandler } from '../types/common';
-import AnalyticsApiClient from './analyticsApiClient';
-import { getClientUniqueId } from './analyticsApiClient/helper';
-
-const APP_NAME = 'LiveDigital';
-const BATCH_SIZE = 50;
-
-export interface RecordMeta {
-  error?: unknown;
-  clientTimestamp: string;
-  from_sdk: boolean;
-  case?: string;
-  channelId?: string;
-  applicationId?: string;
-  peerId?: string;
-  [key: string]: unknown;
-}
-
-export interface ClientMeta {
-  clUId: string;
-  peerId?: string;
-  channelId?: string;
-  appId?: string;
-  [key: string]: unknown;
-}
-
-export interface LoggerParams {
-  logLevel: LogLevel;
-  onLogMessage?: LogMessageHandler;
-  sendAnalytics: boolean;
-}
-
-export interface LoggerConstructorParams {
-  namespace: string;
-  logLevel: LogLevel;
-  onLogMessage?: LogMessageHandler;
-  sendAnalytics: boolean;
-}
-
-export type LogRecordMeta = Record<string, unknown> & {
-  error?: unknown;
-  case?: string;
-  channelId?: string;
-  applicationId?: string;
-  peerId?: string;
-};
-
-export interface LogToRemotePayload {
-  level: LogLevel;
-  message: string;
-  meta?: LogRecordMeta;
-}
-
-class Logger {
-  private readonly _debug: debug.Debugger;
-
-  private readonly _info: debug.Debugger;
-
-  private readonly _warn: debug.Debugger;
-
-  private readonly _error: debug.Debugger;
-
-  readonly #namespace: string;
-
-  readonly #logLevel: LogLevel;
-
-  readonly onLogMessage?: LogMessageHandler;
-
-  readonly #logToRemoteBatcher: MessageBatcher;
-
-  readonly #analyticsApi: AnalyticsApiClient;
-
-  readonly #sendAnalytics: boolean;
-
-  constructor(params: LoggerConstructorParams) {
-    const { logLevel, namespace, onLogMessage } = params;
-    this.#namespace = namespace;
-    this.#logLevel = logLevel;
-    this.onLogMessage = onLogMessage;
-    this.#analyticsApi = new AnalyticsApiClient();
-    this.#logToRemoteBatcher = new MessageBatcher({
-      MaxBatchSize: BATCH_SIZE,
-      MaxDelay: SECOND_IN_MS,
-      MinDelay: HALF_SECOND_IN_MS,
-    });
-    this.#sendAnalytics = params.sendAnalytics;
-
-    this.#logToRemoteBatcher.on('batch', (logs: LogToRemotePayload[]) => {
-      this.logToApi(logs).catch((error: unknown) => {
-        this.error('Failed to log to api', {
-          case: 'Logger',
-          error: serializeError(error),
-        });
-      });
-    });
-
-    this._debug = debug(APP_NAME).extend('debug').extend(this.#namespace);
-    this._info = debug(APP_NAME).extend('info').extend(this.#namespace);
-    this._warn = debug(APP_NAME).extend('warn').extend(this.#namespace);
-    this._error = debug(APP_NAME).extend('error').extend(this.#namespace);
-
-    // eslint-disable-next-line no-console
-    this._debug.log = console.info.bind(console);
-    // eslint-disable-next-line no-console
-    this._info.log = console.info.bind(console);
-    this._warn.log = console.warn.bind(console);
-    this._error.log = console.error.bind(console);
-  }
-
-  debug(message: string, meta: Record<string, unknown>): void {
-    this._debug(message, meta);
-
-    if (this.#sendAnalytics) {
-      this.#logToRemoteBatcher.Queue({ level: 'debug', message, meta });
-    }
-
-    if (this.#logLevel >= LogLevels.Debug) {
-      this.#log('debug', message, meta);
-    }
-  }
-
-  info(message: string, meta: Record<string, unknown>): void {
-    this._info(message, meta);
-
-    if (this.#sendAnalytics) {
-      this.#logToRemoteBatcher.Queue({ level: 'info', message, meta });
-    }
-
-    if (this.#logLevel >= LogLevels.Info) {
-      this.#log('info', message, meta);
-    }
-  }
-
-  warn(message: string, meta: Record<string, unknown>): void {
-    this._warn(message, meta);
-
-    if (this.#sendAnalytics) {
-      this.#logToRemoteBatcher.Queue({ level: 'warn', message, meta });
-    }
-
-    if (this.#logLevel >= LogLevels.Warn) {
-      this.#log('warn', message, meta);
-    }
-  }
-
-  error(message: string, meta: Record<string, unknown>): void {
-    this._error(message, meta);
-
-    if (this.#sendAnalytics) {
-      this.#logToRemoteBatcher.Queue({ level: 'error', message, meta });
-    }
-
-    if (this.#logLevel >= LogLevels.Error) {
-      this.#log('error', message, meta);
-    }
-  }
-
-  #log(level: LogLevelStr, message: string, ...args: readonly unknown[]): void {
-    if (typeof this.onLogMessage === 'function') {
-      this.onLogMessage(message, ...this.#decirculate(args), level);
-    }
-  }
-
-  #decirculate<Input>(object: Input): Input {
-    const seenObjects = new WeakMap<Record<string, unknown>, readonly string[]>();
-
-    function internalDecirculate<T>(value: T, path: readonly string[] = []): T {
-      if (!isObject(value)) {
-        return value;
-      }
-
-      const existingPath = seenObjects.get(value);
-
-      if (existingPath) {
-        return `[Circular *${ existingPath.join('.') }]` as unknown as T;
-      }
-
-      seenObjects.set(value, path);
-
-      const newValue = (Array.isArray(value) ? [] : {}) as T;
-
-      Object.entries(value).forEach(([key, propValue]) => {
-        newValue[key as keyof T] = internalDecirculate(propValue, [...path, key]) as T[keyof T];
-      });
-
-      seenObjects.delete(value);
-
-      return newValue;
-    }
-
-    return internalDecirculate(object);
-  }
-
-  private async logToApi(logs: LogToRemotePayload[]): Promise<void> {
-    try {
-      await this.#analyticsApi.log.batch({
-        logs: logs.map((log) => this.#decirculate({
-          ...log,
-          meta: this.prepareRecordMeta(log.meta),
-        })),
-        clientMeta: this.getClientMeta(),
-      });
-    } catch (error) {
-      this._debug('Log request was not successful', { error });
-    }
-  }
-
-  private getClientMeta(): ClientMeta {
-    return {
-      ...clientMetaProvider.meta,
-      clUId: getClientUniqueId(),
-    };
-  }
-
-  private prepareRecordMeta(metaData?: LogRecordMeta): RecordMeta {
-    const meta = metaData ?? {};
-    const { error } = meta;
-
-    return {
-      ...meta,
-      clientTimestamp: new Date().toISOString(),
-      from_sdk: true,
-      ...(error && typeof error === 'object' ? { error: serializeError(error) } : {}),
-    };
-  }
-}
-
-export default Logger;