@livedigital/client 3.48.0 → 3.49.0

package/src/engine/PeerConsumer.ts

@@ -1,276 +0,0 @@
-import { parseScalabilityMode, type types } from 'mediasoup-client';
-import { serializeError } from 'serialize-error';
-import { SpatialLayer, TemporalLayer } from '../constants/videoConstrains';
-import filterStatsCodecs from '../helpers/filterStatsCodecs';
-import type {
-  ConsumerData,
-  ExtendedRTCInboundRtpStreamStats, SpatialLayerParams,
-  TrackInboundStats,
-} from '../types/common';
-import type Logger from './Logger';
-
-const RESOLUTION_SCALING_FACTOR = 2;
-const STATS_MAX_ATTEMPTS = 5;
-const STATS_ATTEMPT_DELAY = 150;
-
-export interface PeerConsumerDependencies {
-  loggerFactory: (namespace: string) => Logger;
-}
-
-export interface PeerConsumerConstructorParams extends PeerConsumerDependencies {
-  consumer: types.Consumer;
-}
-
-class PeerConsumer {
-  public spatialLayers = SpatialLayer.LOW;
-
-  public temporalLayers = TemporalLayer.BASE;
-
-  public currentSpatialLayer = SpatialLayer.LOW;
-
-  public currentTemporalLayer = TemporalLayer.BASE;
-
-  public requestedSpatialLayer?: number;
-
-  public currentMaxSpatialLayer: number;
-
-  public availableSpatialLayers: SpatialLayerParams[] = [];
-
-  public currentSpatialLayerParams?: SpatialLayerParams;
-
-  readonly id: string;
-
-  readonly kind: types.MediaKind;
-
-  readonly producerId: string;
-
-  readonly appData: ConsumerData;
-
-  private readonly consumer: types.Consumer;
-
-  readonly #logger: Logger;
-
-  constructor(params: PeerConsumerConstructorParams) {
-    const { consumer, loggerFactory } = params;
-    this.id = consumer.id;
-    this.kind = consumer.kind;
-    this.producerId = consumer.producerId;
-    this.appData = consumer.appData as unknown as ConsumerData;
-    this.consumer = consumer;
-    this.#logger = loggerFactory('PeerConsumer');
-    this.currentMaxSpatialLayer = this.appData.producerData.maxSpatialLayer;
-    this.parseScalabilityMode();
-    this.initAvailableSpatialLayers();
-    this.setCurrentSpatialLayerParams();
-  }
-
-  get paused(): boolean {
-    return this.consumer.paused;
-  }
-
-  pause(): void {
-    this.consumer.pause();
-  }
-
-  resume(): void {
-    this.consumer.resume();
-  }
-
-  close(): void {
-    this.consumer.close();
-  }
-
-  get isVideo(): boolean {
-    return this.kind === 'video';
-  }
-
-  get isAudio(): boolean {
-    return this.kind === 'audio';
-  }
-
-  parseScalabilityMode(): void {
-    if (this.consumer.rtpParameters.encodings) {
-      const { scalabilityMode } = this.consumer.rtpParameters.encodings[0];
-      const { spatialLayers, temporalLayers } = parseScalabilityMode(scalabilityMode);
-      this.spatialLayers = spatialLayers;
-      this.temporalLayers = temporalLayers;
-      this.#logger.debug('parseScalabilityMode()', {
-        scalabilityMode,
-        spatialLayers,
-        temporalLayers,
-      });
-    }
-  }
-
-  initAvailableSpatialLayers(): void {
-    const { encodings, trackTransformParams } = this.appData.producerData;
-
-    if (!Array.isArray(encodings)) {
-      return;
-    }
-
-    this.availableSpatialLayers = encodings
-      .map((encoding): SpatialLayerParams => this
-        .tryPrepareSpatialLayerParams(encoding));
-
-    if (!trackTransformParams || this.availableSpatialLayers.length > 1 || this.spatialLayers < SpatialLayer.HIGH) {
-      this.#logger.debug('Using available spatial layers', { case: 'initAvailableSpatialLayers' });
-
-      return;
-    }
-
-    this.#logger.debug('Pre-generating encodings with spatial layer params', { case: 'initAvailableSpatialLayers' });
-
-    const preGeneratedEncodings: SpatialLayerParams[] = [];
-    const baseEncoding = encodings[encodings.length - 1];
-
-    // imitate encodings with spatial layers params for automatic quality switching on client side
-    for (let i = this.spatialLayers - 1; i >= 0; i -= 1) {
-      preGeneratedEncodings.push(this.tryPrepareSpatialLayerParams({
-        ...baseEncoding,
-        scaleResolutionDownBy: RESOLUTION_SCALING_FACTOR ** i,
-      }));
-    }
-
-    this.availableSpatialLayers = preGeneratedEncodings;
-  }
-
-  setCurrentSpatialLayerParams(): void {
-    const { encodings } = this.appData.producerData;
-
-    if (!encodings?.[this.currentSpatialLayer]) {
-      return;
-    }
-
-    this.currentSpatialLayerParams = this.tryPrepareSpatialLayerParams(encodings[this.currentSpatialLayer]);
-    this.#logger.debug('setCurrentSpatialLayerParams()', { currentSpatialLayerParams: this.currentSpatialLayerParams });
-  }
-
-  tryPrepareSpatialLayerParams(encoding: types.RtpEncodingParameters): SpatialLayerParams {
-    const { trackTransformParams } = this.appData.producerData;
-
-    if (!trackTransformParams) {
-      return encoding;
-    }
-
-    const { width, height } = trackTransformParams;
-    const coefficient = encoding.scaleResolutionDownBy ?? 1;
-
-    if (width && height) {
-      return {
-        width: width / coefficient,
-        height: height / coefficient,
-        ...encoding,
-      };
-    }
-
-    return encoding;
-  }
-
-  setCurrentSpatialLayer(currentSpatialLayer: number): void {
-    if (!this.isVideo) {
-      throw new Error('setCurrentSpatialLayer applies to video consumers only');
-    }
-
-    this.currentSpatialLayer = currentSpatialLayer;
-    this.#logger.debug('setCurrentSpatialLayer()', { currentSpatialLayer });
-    this.setCurrentSpatialLayerParams();
-  }
-
-  setCurrentTemporalLayer(currentTemporalLayer: number): void {
-    if (!this.isVideo) {
-      throw new Error('setCurrentTemporalLayer applies to video consumers only');
-    }
-
-    this.currentTemporalLayer = currentTemporalLayer;
-    this.#logger.debug('setCurrentTemporalLayer()', { currentTemporalLayer });
-  }
-
-  applyLayersUpdate(payload: {
-    spatialLayer?: number;
-    temporalLayer?: number;
-  }): void {
-    if (!this.isVideo) {
-      throw new Error('applyLayersUpdate applies to video consumers only');
-    }
-
-    const { spatialLayer, temporalLayer } = payload;
-
-    if (spatialLayer !== undefined) {
-      this.setCurrentSpatialLayer(spatialLayer);
-    }
-
-    if (temporalLayer !== undefined) {
-      this.setCurrentTemporalLayer(temporalLayer);
-    }
-  }
-
-  setRequestedSpatialLayer(spatialLayer: number | undefined): void {
-    this.requestedSpatialLayer = spatialLayer;
-  }
-
-  setCurrentMaxSpatialLayer(spatialLayer: number): void {
-    this.currentMaxSpatialLayer = spatialLayer;
-  }
-
-  async getStats(): Promise<TrackInboundStats | undefined> {
-    try {
-      return {
-        consumerId: this.consumer.id,
-        codec: this.consumer.rtpParameters.codecs.find((codec) => filterStatsCodecs(codec)),
-        dtlsState: this.consumer.rtpReceiver?.transport?.state,
-        availableSpatialLayers: this.availableSpatialLayers,
-        currentSpatialLayerParams: this.currentSpatialLayerParams,
-        requestedSpatialLayer: this.requestedSpatialLayer,
-        rtcStats: await this.getInboundRTPStreamStats(),
-      };
-    } catch (error) {
-      this.#logger.debug('getStats()', { error });
-
-      return undefined;
-    }
-  }
-
-  async getInboundRTPStreamStats(): Promise<ExtendedRTCInboundRtpStreamStats> {
-    return await new Promise((resolve, reject) => {
-      const getRTCStatsReport = async (attempt = 0): Promise<void> => {
-        try {
-          const rtcStatsReport = await this.consumer.getStats();
-          const inboundRTPStreamStats: ExtendedRTCInboundRtpStreamStats = Array.from(rtcStatsReport.values())
-            .find((stat) => stat.type === 'inbound-rtp');
-
-          if (!inboundRTPStreamStats && attempt < STATS_MAX_ATTEMPTS) {
-            setTimeout(() => {
-              getRTCStatsReport(attempt + 1).catch((error: unknown) => {
-                this.#logger.debug('Error getting RTCStatsReport', {
-                  attempt,
-                  error: serializeError(error),
-                });
-              });
-            }, STATS_ATTEMPT_DELAY);
-
-            return;
-          }
-
-          if (attempt >= STATS_MAX_ATTEMPTS && !inboundRTPStreamStats) {
-            reject(new Error('InboundRTPStreamStat not exist'));
-          }
-
-          resolve(inboundRTPStreamStats);
-        } catch (error) {
-          reject(new Error('Can not get RTCStatsReport'));
-          this.#logger.debug('getInboundRTPStreamStats()', { error });
-        }
-      };
-
-      getRTCStatsReport().catch((error: unknown) => {
-        this.#logger.debug('Error executing getRTCStatsReport', {
-          case: 'PeerConsumer',
-          error: serializeError(error),
-        });
-      });
-    });
-  }
-}
-
-export default PeerConsumer;

package/src/engine/PeerProducer.ts

@@ -1,50 +0,0 @@
-import type { MediaKind } from 'mediasoup-client/lib/RtpParameters';
-import type { RtpEncodingParameters } from 'mediasoup-client/lib/types';
-import type { ProducerData, TrackLabel, TrackTransformParams } from '../types/common';
-
-class PeerProducer {
-  readonly id: string;
-
-  readonly kind: MediaKind;
-
-  readonly peerId: string;
-
-  readonly label: TrackLabel;
-
-  public paused: boolean;
-
-  readonly encodings: RtpEncodingParameters[] = [];
-
-  readonly maxSpatialLayer: number;
-
-  readonly trackTransformParams?: TrackTransformParams;
-
-  #stateChangedAt: number;
-
-  constructor(params: ProducerData) {
-    const {
-      id, kind, peerId, label, paused,
-    } = params;
-
-    this.id = id;
-    this.kind = kind;
-    this.peerId = peerId;
-    this.label = label;
-    this.paused = paused;
-    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;
-  }
-}
-
-export default PeerProducer;

package/src/engine/Peers.ts

@@ -1,150 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { CLIENT_EVENTS } from '../constants/events';
-import EnhancedEventEmitter from '../EnhancedEventEmitter';
-import { TOKEN } from '../inversify.tokens';
-import {
-  PeerGroup,
-  PeerResponse,
-  ProducerData,
-  Role,
-  TrackLabel,
-} from '../types/common';
-import type { PeerFactory } from '../types/container';
-import { MyPeer } from './MyPeer';
-import Network from './network';
-import Peer from './Peer';
-import PeerConsumer from './PeerConsumer';
-import PeersStorage from './PeersStorage';
-
-export interface IPeersService {
-  has: (id: Peer['id']) => boolean;
-  get: (id: Peer['id']) => Peer | undefined;
-  remove: (id: Peer['id']) => Promise<void>;
-  all: () => Peer[];
-  hosts: () => Peer[];
-  audience: () => Peer[];
-  reset: () => Promise<void>;
-  load: (role?: Role) => Promise<void>;
-  add: (peerData: PeerResponse, emit: boolean) => Peer;
-  isModerator: (id: Peer['id'] | undefined) => boolean;
-}
-
-export interface CreatePeerParams {
-  id: string;
-  channelIds: string[];
-  groups: PeerGroup[];
-  producePermissions: TrackLabel[];
-  appId: string;
-  producers: ProducerData[];
-  videoConsumer?: PeerConsumer;
-  audioConsumer?: PeerConsumer;
-  soundLevel?: number;
-  loginDate: Date;
-  uid?: string;
-  appData?: Record<string, unknown>;
-  role: Role;
-}
-
-@injectable()
-export class Peers implements IPeersService {
-  constructor(
-    @inject(TOKEN.MyPeer) private readonly myPeer: MyPeer,
-    @inject(TOKEN.Network) private readonly network: Network,
-    @inject(TOKEN.PeerFactory) private readonly peerFactory: PeerFactory,
-    @inject(TOKEN.ClientEventEmitter) private readonly clientEventEmitter: EnhancedEventEmitter,
-    @inject(TOKEN.PeersStorage) private readonly peersStorage: PeersStorage,
-  ) { }
-
-  has(id: Peer['id']): boolean {
-    return this.peersStorage.has(id);
-  }
-
-  private set(id: Peer['id'], peer: Peer): void {
-    if (id === this.myPeer.id) {
-      this.myPeer.set(peer);
-    }
-
-    this.peersStorage.set(id, peer);
-  }
-
-  get(id: Peer['id']): Peer | undefined {
-    return this.peersStorage.get(id);
-  }
-
-  private delete(id: Peer['id']): boolean {
-    if (id === this.myPeer.id) {
-      this.myPeer.delete();
-    }
-
-    return this.peersStorage.delete(id);
-  }
-
-  async remove(id: Peer['id']): Promise<void> {
-    const peer = this.get(id);
-
-    if (!peer) {
-      return;
-    }
-
-    await peer.reset();
-
-    this.delete(id);
-    this.clientEventEmitter.safeEmit(CLIENT_EVENTS.peerLeft, id);
-  }
-
-  all(): Peer[] {
-    return this.peersStorage.all();
-  }
-
-  hosts(): Peer[] {
-    return this.peersStorage.hosts();
-  }
-
-  audience(): Peer[] {
-    return this.peersStorage.audience();
-  }
-
-  async reset(): Promise<void> {
-    await Promise.all(this.peersStorage.all().map(async (peer) => await peer.reset()));
-    this.peersStorage.clear();
-  }
-
-  async load(role?: Role): Promise<void> {
-    const { peers } = await this.network.getChannelPeers(role);
-    peers
-      .filter((peer) => !this.has(peer.id))
-      .forEach((peer) => this.add(peer, false));
-  }
-
-  add(peerData: PeerResponse, emit = true): Peer {
-    const existingPeer = this.get(peerData.id);
-
-    if (existingPeer) {
-      return existingPeer;
-    }
-
-    const peer = this.peerFactory(peerData);
-
-    this.set(peer.id, peer);
-
-    if (emit) {
-      this.clientEventEmitter.safeEmit(CLIENT_EVENTS.peerJoined, peer);
-    }
-
-    return peer;
-  }
-
-  isModerator(id: Peer['id'] | undefined): boolean {
-    if (id === undefined) {
-      return false;
-    }
-
-    const peer = this.get(id);
-
-    if (peer) {
-      return peer.isModerator;
-    }
-
-    return false;
-  }
-}

package/src/engine/PeersStorage.ts

@@ -1,45 +0,0 @@
-import { injectable } from 'inversify';
-import Peer from './Peer';
-
-@injectable()
-class PeersStorage {
-  private readonly peers = new Map<Peer['id'], Peer>();
-
-  has(id: Peer['id']): boolean {
-    return this.peers.has(id);
-  }
-
-  set(id: Peer['id'], peer: Peer): void {
-    this.peers.set(id, peer);
-  }
-
-  get(id: Peer['id']): Peer | undefined {
-    return this.peers.get(id);
-  }
-
-  delete(id: Peer['id']): boolean {
-    return this.peers.delete(id);
-  }
-
-  all(): Peer[] {
-    return Array.from(this.peers.values());
-  }
-
-  hosts(): Peer[] {
-    return this
-      .all()
-      .filter((peer) => peer.role === 'host');
-  }
-
-  audience(): Peer[] {
-    return this
-      .all()
-      .filter((peer) => peer.role === 'audience');
-  }
-
-  clear(): void {
-    this.peers.clear();
-  }
-}
-
-export default PeersStorage;

package/src/engine/RemotePeerTracks.ts

@@ -1,73 +0,0 @@
-import { inject, injectable } from 'inversify';
-import EnhancedEventEmitter from '../EnhancedEventEmitter';
-import { TOKEN } from '../inversify.tokens';
-import { TrackLabel } from '../types/common';
-import type { PeerTrackFactory } from '../types/container';
-import PeerTrack from './media/tracks/PeerTrack';
-import { PeerObserverEvents } from './Peer';
-import PeerConsumer from './PeerConsumer';
-
-export interface CreatePeerTrackParams {
-  consumer?: PeerConsumer;
-  label: TrackLabel;
-  mediaStreamTrack: MediaStreamTrack;
-  muted: boolean;
-  paused: boolean;
-  peerEventEmitter: EnhancedEventEmitter<PeerObserverEvents>;
-}
-
-@injectable()
-export class RemotePeerTracks {
-  private readonly tracksByConsumerId = new Map<PeerTrack['consumerId'], PeerTrack>();
-
-  constructor(
-    @inject(TOKEN.PeerTrackFactory) private readonly peerTrackFactory: PeerTrackFactory,
-  ) { }
-
-  register(consumerId: PeerTrack['consumerId'], track: PeerTrack): void {
-    this.tracksByConsumerId.set(consumerId, track);
-  }
-
-  get(consumerId: PeerTrack['consumerId']): PeerTrack | undefined {
-    return this.tracksByConsumerId.get(consumerId);
-  }
-
-  delete(consumerId: PeerTrack['consumerId']): boolean {
-    return this.tracksByConsumerId.delete(consumerId);
-  }
-
-  reset(): void {
-    this.tracksByConsumerId.clear();
-  }
-
-  create(params: CreatePeerTrackParams): PeerTrack {
-    const {
-      consumer,
-      label,
-      muted = false,
-      mediaStreamTrack,
-      paused,
-      peerEventEmitter,
-    } = params;
-
-    const peerTrack = this.peerTrackFactory({
-      consumer,
-      label,
-      mediaStreamTrack,
-      paused,
-      peerEventEmitter,
-      muted,
-      onClose: () => {
-        if (peerTrack.consumerId !== undefined) {
-          this.delete(peerTrack.consumerId);
-        }
-      },
-    });
-
-    if (peerTrack.consumerId !== undefined) { // only register remote tracks
-      this.register(peerTrack.consumerId, peerTrack);
-    }
-
-    return peerTrack;
-  }
-}