@livedigital/client 3.48.0 → 3.49.1

package/src/engine/MyPeer.ts

@@ -1,25 +0,0 @@
-import { injectable } from 'inversify';
-import Peer from './Peer';
-
-@injectable()
-export class MyPeer {
-  id?: Peer['id'];
-
-  private peer?: Peer;
-
-  get(): Peer | undefined {
-    return this.peer;
-  }
-
-  set(peer: Peer): void {
-    this.peer = peer;
-  }
-
-  delete(): void {
-    this.peer = undefined;
-  }
-
-  get canPublish(): boolean {
-    return this.peer?.role === 'host';
-  }
-}

package/src/engine/Peer.ts

@@ -1,602 +0,0 @@
-import { serializeError } from 'serialize-error';
-import {
-  CHANNEL_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS,
-} from '../constants/events';
-import EnhancedEventEmitter from '../EnhancedEventEmitter';
-import OperationError from '../errors/OperationError';
-import validateAppData from '../helpers/appDataValidator';
-import { logResponse } from '../helpers/peer';
-import {
-  type ChangePreferredLayersPayload, type PayloadOfPublishedMedia,
-  type PayloadOfUnpublishedMedia, type PeerGroup, type PeerInfo, type PeerShortData, type ProducerData,
-  type ProducerSetMaxSpatialLayer, type Role, type SubscribeOptions, TrackLabel, type TrackLabelString,
-} from '../types/common';
-import type { PeerConsumerFactory } from '../types/container';
-import type { GroupsChangedPayload, ProducePermissionsChangedPayload } from '../types/engine';
-import type { CallState } from './CallState';
-import type Logger from './Logger';
-import type Media from './media';
-import type PeerTrack from './media/tracks/PeerTrack';
-import type { MyPeer } from './MyPeer';
-import type Network from './network';
-import type PeerConsumer from './PeerConsumer';
-import PeerProducer from './PeerProducer';
-import type { Peers } from './Peers';
-import type { RemotePeerTracks } from './RemotePeerTracks';
-
-export interface PeerDependencies {
-  callState: CallState;
-  loggerFactory: (namespace: string) => Logger;
-  media: Media;
-  myPeer: MyPeer;
-  network: Network;
-  peers: Peers;
-  remotePeerTracks: RemotePeerTracks;
-  peerConsumerFactory: PeerConsumerFactory;
-}
-
-interface PeerConstructor extends PeerDependencies {
-  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;
-}
-
-export interface PeerObserverEvents {
-  [PEER_EVENTS.mediaPublished]: [PayloadOfPublishedMedia];
-  [PEER_EVENTS.appDataUpdated]: [Record<string, unknown>];
-  [PEER_EVENTS.connectionQualityChanged]: [{ connectionQuality: number }];
-  [PEER_EVENTS.publisherPaused]: [PayloadOfPublishedMedia];
-  [PEER_EVENTS.publisherResumed]: [PayloadOfPublishedMedia];
-  [PEER_EVENTS.mediaUnPublished]: [PayloadOfUnpublishedMedia];
-  [PEER_EVENTS.trackStart]: [PeerTrack];
-  [PEER_EVENTS.trackEnd]: [PeerTrack];
-  [PEER_EVENTS.trackResumed]: [PeerTrack];
-  [PEER_EVENTS.trackPaused]: [PeerTrack];
-  [PEER_EVENTS.trackFailed]: [PeerTrack];
-  [PEER_EVENTS.producePermissionsChanged]: [ProducePermissionsChangedPayload];
-  [PEER_EVENTS.groupsChanged]: [GroupsChangedPayload];
-  [MEDIASOUP_EVENTS.producerClose]: [ProducerData];
-  [MEDIASOUP_EVENTS.newProducer]: [ProducerData];
-  [MEDIASOUP_EVENTS.closeConsumer]: [consumerId: string];
-  [MEDIASOUP_EVENTS.pauseConsumer]: [consumerId: string];
-  [MEDIASOUP_EVENTS.resumeConsumer]: [consumerId: string];
-  [MEDIASOUP_EVENTS.consumerChangePreferredLayers]: [ChangePreferredLayersPayload];
-  [MEDIASOUP_EVENTS.producerSetMaxSpatialLayer]: [ProducerSetMaxSpatialLayer];
-  [CHANNEL_EVENTS.updatePeerAppData]: [Record<string, unknown>];
-  [event: string]: unknown[];
-}
-
-class Peer {
-  public id: string;
-
-  public channelIds: string[];
-
-  public groups: PeerGroup[];
-
-  public producePermissions: TrackLabel[];
-
-  public appId: string;
-
-  public loginDate: Date;
-
-  public uid?: string;
-
-  private applicationData: Record<string, unknown>;
-
-  public role: Role;
-
-  producers = new Map<string, PeerProducer>();
-
-  public readonly tracks = new Map<string, PeerTrack>();
-
-  readonly #peers: Peers;
-
-  readonly #remotePeerTracks: RemotePeerTracks;
-
-  readonly #network: Network;
-
-  readonly #media: Media;
-
-  readonly #myPeer: MyPeer;
-
-  readonly #callState: CallState;
-
-  readonly #peerConsumerFactory: PeerConsumerFactory;
-
-  readonly #logger: Logger;
-
-  private readonly _observer = new EnhancedEventEmitter<PeerObserverEvents>();
-
-  constructor({
-    id,
-    channelIds,
-    groups,
-    producePermissions,
-    appId,
-    loginDate,
-    producers = [],
-    appData,
-    uid,
-    role,
-    loggerFactory,
-    myPeer,
-    callState,
-    peers,
-    remotePeerTracks,
-    media,
-    network,
-    peerConsumerFactory,
-  }: PeerConstructor) {
-    this.id = id;
-    this.channelIds = channelIds;
-    this.groups = groups;
-    this.producePermissions = producePermissions;
-    this.appId = appId;
-    this.loginDate = loginDate;
-    this.applicationData = appData ?? {};
-    this.uid = uid;
-    this.role = role;
-    this.#myPeer = myPeer;
-    this.#callState = callState;
-    this.#peers = peers;
-    this.#remotePeerTracks = remotePeerTracks;
-    this.#peerConsumerFactory = peerConsumerFactory;
-    this.#network = network;
-    this.#media = media;
-    this.#logger = loggerFactory('Peer');
-    producers.forEach(this.handleNewProducer.bind(this));
-    this.handlePeerEvents();
-  }
-
-  get appData(): Record<string, unknown> {
-    return this.applicationData;
-  }
-
-  get observer(): EnhancedEventEmitter<PeerObserverEvents> {
-    return this._observer;
-  }
-
-  public get isMe(): boolean {
-    return this.id === this.#myPeer.id;
-  }
-
-  public get isModerator(): boolean {
-    return this.groups.includes('moderator');
-  }
-
-  public get isUser(): boolean {
-    return this.groups.includes('user');
-  }
-
-  public get publishedMedia(): PayloadOfPublishedMedia[] {
-    return Array.from(this.producers.values()).map((producer) => ({
-      producerId: producer.id,
-      kind: producer.kind,
-      label: producer.label,
-      paused: producer.paused,
-    }));
-  }
-
-  get shortData(): PeerShortData {
-    return {
-      id: this.id,
-      producers: Array.from(this.producers.values()).map((producer) => ({
-        id: producer.id,
-        paused: producer.paused,
-      })),
-      appData: this.appData,
-    };
-  }
-
-  public hasPermission(producePermission: TrackLabel): boolean {
-    return this.producePermissions.includes(producePermission);
-  }
-
-  public hasGroup(group: PeerGroup): boolean {
-    return this.groups.includes(group);
-  }
-
-  public async subscribe({ producerId, muted = false }: SubscribeOptions): Promise<void> {
-    try {
-      const producer = this.producers.get(producerId);
-
-      if (!producer) {
-        this.#logger.warn('subscribe()',
-          { message: 'Peer does not have a producer', peer: logResponse(this), producerId });
-
-        return;
-      }
-
-      const peerConsumer = this.getAllConsumers().find((item) => item.producerId === producerId);
-
-      if (peerConsumer) {
-        this.#logger.debug('subscribe()',
-          { message: 'Already subscribed to producer', peer: logResponse(this), producerId });
-
-        return;
-      }
-
-      const { consumer, isProducerPaused } = await this.#network.createConsumer({
-        producerId: producer.id,
-        rtpCapabilities: this.#media.mediasoupDevice.rtpCapabilities,
-        producerPeerId: this.id,
-        appId: this.#callState.appId,
-        channelId: this.#callState.channelId,
-      });
-
-      // it happens when moderator removes permissions for a track during the creating of a consumer
-      if (!this.producePermissions.includes(producer.label) && Object.values(TrackLabel).includes(producer.label)) {
-        this.#logger.debug('subscribe()',
-          { message: 'Producer is not allowed anymore', peer: logResponse(this), producerId });
-
-        return;
-      }
-
-      const track = this.#remotePeerTracks.create({
-        mediaStreamTrack: consumer.track,
-        label: producer.label,
-        consumer: this.#peerConsumerFactory({
-          consumer,
-        }),
-        muted,
-        paused: isProducerPaused,
-        peerEventEmitter: this.observer,
-      });
-
-      if (!muted) {
-        await track.unmute();
-      }
-
-      this.tracks.set(track.label, track);
-      this.#logger.debug(`Subscribed for ${ producer.kind }`, { peer: logResponse(this) });
-    } catch (error) {
-      this.#logger.error('subscribe()', { producerId, error, peer: logResponse(this) });
-      throw new OperationError('peer_subscribe_failed', error);
-    }
-  }
-
-  public async unsubscribe(producerId: string): Promise<void> {
-    try {
-      const consumer = this.getConsumerByProducerId(producerId);
-
-      if (!consumer) {
-        return;
-      }
-
-      const track = this.getTrackByConsumerId(consumer.id);
-
-      if (!track) {
-        return;
-      }
-
-      await track.close();
-      this.tracks.delete(track.label);
-      this.#logger.debug(`Unsubscribed consumer ${ consumer.kind }`, { peer: logResponse(this) });
-    } catch (error) {
-      this.#logger.error('unsubscribe()', { producerId, error });
-      throw new OperationError('peer_unsubscribe_failed', error);
-    }
-  }
-
-  public async setProducePermissions(producePermissions: TrackLabelString[]): Promise<void> {
-    this.throwIfIamNotModerator();
-
-    try {
-      await this.#network.changePeerProducePermissions(this.id, producePermissions);
-    } catch (error) {
-      throw new OperationError('peer_set_produce_permissions_failed', error);
-    }
-
-    this.#logger.debug('Produce permissions changed', { peerId: this.id, producePermissions });
-  }
-
-  public async addProducePermission(label: TrackLabelString): Promise<void> {
-    this.throwIfIamNotModerator();
-
-    try {
-      await this.#network.addPeerProducePermission(this.id, label);
-    } catch (error) {
-      throw new OperationError('peer_add_produce_permission_failed', error);
-    }
-
-    this.#logger.debug('Add produce permission requested', { peerId: this.id, label });
-  }
-
-  public async removeProducePermission(label: TrackLabelString): Promise<void> {
-    this.throwIfIamNotModerator();
-
-    try {
-      await this.#network.removePeerProducePermission(this.id, label);
-    } catch (error) {
-      throw new OperationError('peer_remove_produce_permission_failed', error);
-    }
-
-    this.#logger.debug('Remove produce permission requested', { peerId: this.id, label });
-  }
-
-  async getInfo(): Promise<PeerInfo> {
-    try {
-      return {
-        id: this.id,
-        appData: this.appData,
-        role: this.role,
-        channelIds: this.channelIds,
-        appId: this.appId,
-        uid: this.uid,
-        loginDate: this.loginDate,
-        tracks: await Promise.all(Array.from(this.tracks.values()).map(async (track) => await track.getInfo())),
-      };
-    } catch (error) {
-      this.#logger.error('getInfo()', { peer: logResponse(this), error });
-      throw new OperationError('peer_get_info_failed', error);
-    }
-  }
-
-  getProducers(): PeerProducer[] {
-    return Array.from(this.producers.values());
-  }
-
-  getConsumersState(): Array<{ id: string; producerId: string; paused: boolean }> {
-    return this.getAllConsumers().map((consumer) => ({
-      id: consumer.id,
-      paused: consumer.paused,
-      producerId: consumer.producerId,
-    }));
-  }
-
-  private handleNewProducer(producerData: ProducerData): void {
-    if (this.producers.get(producerData.id)) {
-      return;
-    }
-
-    const producer = new PeerProducer(producerData);
-    this.producers.set(producer.id, producer);
-    this.#logger.debug('Peer published media:', { peer: logResponse(this), producer });
-    const payload: PayloadOfPublishedMedia = {
-      producerId: producer.id,
-      kind: producer.kind,
-      label: producer.label,
-      paused: producer.paused,
-    };
-    this.observer.safeEmit(PEER_EVENTS.mediaPublished, payload);
-  }
-
-  private handlePeerEvents(): void {
-    this.observer.on(MEDIASOUP_EVENTS.newProducer, this.handleNewProducer.bind(this));
-
-    this.observer.on(MEDIASOUP_EVENTS.producerClose, async (producer: ProducerData): Promise<void> => {
-      this.producers.delete(producer.id);
-      this.#logger.debug('Peer unpublished media:', { peer: logResponse(this), producer });
-      this.observer.safeEmit(PEER_EVENTS.mediaUnPublished, {
-        producerId: producer.id,
-        kind: producer.kind,
-        label: producer.label,
-        paused: producer.paused,
-      });
-
-      const track = this.tracks.get(producer.label);
-
-      if (!track) {
-        return;
-      }
-
-      try {
-        await track.close();
-      } catch (error) {
-        this.#logger.warn('Failed to close peer track due to producer closed', {
-          label: track.label,
-          peerId: this.id,
-          error: serializeError(error),
-        });
-      }
-    });
-
-    this.observer.on(MEDIASOUP_EVENTS.closeConsumer, async (consumerId): Promise<void> => {
-      const track = this.getTrackByConsumerId(consumerId);
-
-      if (!track) {
-        return;
-      }
-
-      await track.close();
-      this.tracks.delete(track.label);
-      this.#logger.debug('Peer video track was ended:', { peer: logResponse(this), track: track.logCtx });
-    });
-
-    this.observer.on(MEDIASOUP_EVENTS.pauseConsumer, async (consumerId): Promise<void> => {
-      const track = this.getTrackByConsumerId(consumerId);
-
-      if (!track) {
-        return;
-      }
-
-      await track.pause(false);
-    });
-
-    this.observer.on(MEDIASOUP_EVENTS.resumeConsumer, async (consumerId): Promise<void> => {
-      const track = this.getTrackByConsumerId(consumerId);
-
-      if (!track) {
-        return;
-      }
-
-      await track.resume(false);
-    });
-
-    this.observer.on(MEDIASOUP_EVENTS.consumerChangePreferredLayers, (payload: ChangePreferredLayersPayload): void => {
-      const consumer = this.getConsumerById(payload.consumerId);
-
-      if (consumer?.isVideo) {
-        consumer.applyLayersUpdate({
-          spatialLayer: payload.spatialLayer,
-          temporalLayer: payload.temporalLayer,
-        });
-
-        if (payload.spatialLayer === consumer.requestedSpatialLayer) {
-          consumer.setRequestedSpatialLayer(undefined);
-        }
-
-        this.#logger.debug('consumerChangePreferredLayers()', { ...payload });
-      }
-    });
-
-    this.observer.on(MEDIASOUP_EVENTS.producerSetMaxSpatialLayer, async (
-      payload: ProducerSetMaxSpatialLayer,
-    ): Promise<void> => {
-      const { producerId, spatialLayer } = payload;
-      const consumer = this.getConsumerByProducerId(producerId);
-
-      if (!consumer) {
-        this.#logger.debug('producerSetMaxSpatialLayer()', {
-          message: 'Consumer for producer not created, ignore MaxSpatialLayer change',
-        });
-
-        return;
-      }
-
-      consumer.setCurrentMaxSpatialLayer(spatialLayer);
-      this.#logger.debug('producerSetMaxSpatialLayer()', {
-        producerId,
-        consumerId: consumer.id,
-        spatialLayer,
-      });
-
-      if (consumer.requestedSpatialLayer !== spatialLayer) {
-        this.#logger.debug('producerSetMaxSpatialLayer()', {
-          message: 'No need to request new preferred layer',
-          currentMaxSpatialLayer: spatialLayer,
-          requestedMaxSpatialLayer: consumer.requestedSpatialLayer,
-        });
-
-        return;
-      }
-
-      await this.#network.updateConsumerPreferredLayers(consumer.id, spatialLayer);
-
-      this.#logger.debug('requestVideoPreferredLayers()', {
-        producerId,
-        consumerId: consumer.id,
-        spatialLayer,
-      });
-    });
-
-    this.observer.on(CHANNEL_EVENTS.updatePeerAppData, (appData: Record<string, unknown>): void => {
-      try {
-        validateAppData(appData);
-        this.setAppData(appData);
-        this.observer.emit(PEER_EVENTS.appDataUpdated, appData);
-        this.#logger.debug('updatePeerAppData', { peer: logResponse(this), appData });
-      } catch (error) {
-        this.#logger.error('updatePeerAppData', { peer: logResponse(this), appData, error });
-      }
-    });
-  }
-
-  async reset(): Promise<void> {
-    this.producers.clear();
-
-    await Promise.all(Array.from(this.tracks.values()).map(async (track): Promise<void> => await track.close()));
-    this.tracks.clear();
-
-    const eventNames = [
-      MEDIASOUP_EVENTS.newProducer,
-      MEDIASOUP_EVENTS.producerClose,
-      MEDIASOUP_EVENTS.closeConsumer,
-      MEDIASOUP_EVENTS.pauseConsumer,
-      MEDIASOUP_EVENTS.resumeConsumer,
-      MEDIASOUP_EVENTS.consumerChangePreferredLayers,
-      MEDIASOUP_EVENTS.producerSetMaxSpatialLayer,
-      CHANNEL_EVENTS.updatePeerAppData,
-    ];
-
-    eventNames.forEach((x): EnhancedEventEmitter<PeerObserverEvents> => this.observer.removeAllListeners(x));
-  }
-
-  getActiveTracksCount(): number {
-    return Array.from(this.tracks.values())
-      .map((track) => track.consumer)
-      .filter((consumer) => !consumer?.paused)
-      .length;
-  }
-
-  getActivePublishersCount(): number {
-    return Array.from(this.producers.values())
-      .filter((producer) => !producer.paused)
-      .length;
-  }
-
-  handleProducePermissionsChange(producePermissions: TrackLabel[]): void {
-    this.producePermissions = producePermissions;
-
-    // close tracks that are no longer allowed
-    Object.values(TrackLabel)
-      .filter((label) => !this.producePermissions.includes(label))
-      .forEach((label) => {
-        const track = this.tracks.get(label);
-
-        if (track) {
-          this.tracks.delete(track.label);
-          track.close().catch((error: unknown) => {
-            this.#logger.error('Failed to close track', {
-              case: 'Peer',
-              error: serializeError(error),
-            });
-          });
-        }
-      });
-
-    // notify about changes in permissions
-    this.observer.safeEmit(PEER_EVENTS.producePermissionsChanged, {
-      labels: this.producePermissions,
-    });
-  }
-
-  handleGroupsChange(groups: PeerGroup[]): void {
-    this.groups = groups;
-    this.observer.safeEmit(PEER_EVENTS.groupsChanged, { groups });
-  }
-
-  private getAllConsumers(): PeerConsumer[] {
-    return Array.from(this.tracks.values())
-      .map((track) => track.consumer)
-      .filter((item): item is PeerConsumer => !!item);
-  }
-
-  private getConsumerByProducerId(producerId: string): PeerConsumer | undefined {
-    return this.getAllConsumers().find((consumer) => consumer.producerId === producerId);
-  }
-
-  private getConsumerById(id: string): PeerConsumer | undefined {
-    return this.getAllConsumers().find((consumer) => consumer.id === id);
-  }
-
-  private getTrackByConsumerId(id: string): PeerTrack | undefined {
-    return Array.from(this.tracks.values()).find((track) => track.consumerId === id);
-  }
-
-  private setAppData(appData: Record<string, unknown>): void {
-    this.applicationData = appData;
-  }
-
-  private throwIfIamNotModerator(): void {
-    const isIamModerator = this.#peers.isModerator(this.#myPeer.id);
-
-    if (isIamModerator) {
-      return;
-    }
-
-    throw new OperationError('not_enough_access', new Error('Not enough access'));
-  }
-}
-
-export default Peer;