@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.11

package/src/metrics/{index.js → index.ts}

@@ -18,6 +18,7 @@ import {
 } from './config';
 
 const OSMap = {
+  // @ts-ignore
   'Chrome OS': OS_NAME.chrome,
   macOS: OS_NAME.MAC,
   Windows: OS_NAME.WINDOWS,
@@ -76,6 +77,13 @@ const triggerTimers = ({event, meeting, data}) => {
  * @class Metrics
  */
 class Metrics {
+  static instance: Metrics;
+
+  _events: any;
+  keys: any;
+  meetingCollection: any;
+  webex: any;
+
   /**
      * Create Metrics Object
      * @constructor
@@ -125,7 +133,7 @@ class Metrics {
    *
    * @returns {void}
    */
-  initialSetup(meetingCollection, webex) {
+  initialSetup(meetingCollection: object, webex: object) {
     this.meetingCollection = meetingCollection;
     this.webex = webex;
   }
@@ -139,7 +147,7 @@ class Metrics {
    * @param {object} options.event
    * @returns {object} null
    */
-  postEvent(options) {
+  postEvent(options: { meeting?: any; meetingId?: string; data?: object; event?: any } | any) {
     const {meetingId, data = {}, event} = options;
     let {meeting} = options;
 
@@ -181,7 +189,7 @@ class Metrics {
  */
 
   initPayload(eventType, identifiers, options) {
-    const payload = {
+    const payload: any = {
       eventId: uuid.v4(),
       version: 1,
       origin: {
@@ -252,7 +260,7 @@ class Metrics {
    * @private
    * @memberof Metrics
    */
-  getOsName() {
+  private getOsName() {
     return OSMap[getOSName()] ?? OS_NAME.OTHERS;
   }
 
@@ -270,7 +278,18 @@ class Metrics {
    * @public
    * @memberof Metrics
    */
-  initMediaPayload(eventType, identifiers, options = {}) {
+  public initMediaPayload(
+    eventType: string,
+    identifiers: {
+      correlationId: string;
+      locusUrl: string;
+      locusId: string;
+    },
+    options: {
+      intervalData: object;
+      clientType: string;
+    } | any = {}
+  ) {
     const {audioSetupDelay, videoSetupDelay, joinTimes} = options;
 
     const payload = {
@@ -329,7 +348,7 @@ class Metrics {
    * @returns {{showToUser: boolean, category: string, errorDescription: string,
    *  errorCode: number, errorData: *, fatal: boolean, name: string}}
    */
-  parseLocusError(err, showToUser) {
+  parseLocusError(err: any, showToUser: boolean) {
     let errorCode;
 
     if (err && err.statusCode && err.statusCode >= 500) {
@@ -447,7 +466,7 @@ class Metrics {
 
   generateErrorPayload(errorCode, shownToUser, name, err) {
     if (error.errors[errorCode]) {
-      const errorPayload = {
+      const errorPayload: any = {
         shownToUser: shownToUser || false,
         category: error.errors[errorCode][2],
         errorDescription: error.errors[errorCode][0],
@@ -515,7 +534,7 @@ class Metrics {
    *
    * @returns {void}
    */
-  sendBehavioralMetric(metricName, metricFields = {}, metricTags = {}) {
+  sendBehavioralMetric(metricName: string, metricFields: object = {}, metricTags: object = {}) {
     this.webex.internal.metrics.submitClientMetrics(metricName, {
       type: this.webex.config.metrics.type,
       fields: metricFields,

package/src/multistream/mediaRequestManager.ts

@@ -0,0 +1,166 @@
+/* eslint-disable require-jsdoc */
+import {MediaConnection as MC} from '@webex/internal-media-core';
+
+import LoggerProxy from '../common/logs/logger-proxy';
+
+import {ReceiveSlot, ReceiveSlotId} from './receiveSlot';
+
+export interface ActiveSpeakerPolicyInfo {
+  policy: 'active-speaker';
+  priority: number;
+  crossPriorityDuplication: boolean;
+  crossPolicyDuplication: boolean;
+  preferLiveVideo: boolean;
+}
+
+export interface ReceiverSelectedPolicyInfo {
+  policy: 'receiver-selected';
+  csi: number;
+}
+
+export type PolicyInfo = ActiveSpeakerPolicyInfo | ReceiverSelectedPolicyInfo;
+
+export interface H264CodecInfo {
+  codec: 'h264';
+  maxFs?: number;
+  maxFps?: number;
+  maxMbps?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+}
+
+export type CodecInfo = H264CodecInfo; // we'll add AV1 here in the future when it's available
+
+export interface MediaRequest {
+  policyInfo: PolicyInfo;
+  receiveSlots: Array<ReceiveSlot>;
+  codecInfo?: CodecInfo;
+}
+
+export type MediaRequestId = string;
+
+const CODEC_DEFAULTS = {
+  h264: {
+    maxFs: 8192,
+    maxFps: 3000,
+    maxMbps: 245760,
+  },
+};
+
+type SendMediaRequestsCallback = (mediaRequests: MC.MediaRequest[]) => void;
+
+export class MediaRequestManager {
+  private sendMediaRequestsCallback: SendMediaRequestsCallback;
+
+  private counter;
+
+  private clientRequests: {[key: MediaRequestId]: MediaRequest};
+
+  private slotsActiveInLastMediaRequest: {[key: ReceiveSlotId]: ReceiveSlot};
+
+  constructor(sendMediaRequestsCallback: SendMediaRequestsCallback) {
+    this.sendMediaRequestsCallback = sendMediaRequestsCallback;
+    this.counter = 0;
+    this.clientRequests = {};
+    this.slotsActiveInLastMediaRequest = {};
+  }
+
+  private resetInactiveReceiveSlots() {
+    const activeSlots: {[key: ReceiveSlotId]: ReceiveSlot} = {};
+
+    // create a map of all currently used slot ids
+    Object.values(this.clientRequests).forEach((request) =>
+      request.receiveSlots.forEach((slot) => {
+        activeSlots[slot.id] = slot;
+      })
+    );
+
+    // when we stop using some receive slots and they are not included in the new media request,
+    // we will never get a 'no source' notification for them, so we reset their state,
+    // so that the client doesn't try to display their video anymore
+    for (const [slotId, slot] of Object.entries(this.slotsActiveInLastMediaRequest)) {
+      if (!(slotId in activeSlots)) {
+        LoggerProxy.logger.info(
+          `multistream:mediaRequestManager --> resetting sourceState to "no source" for slot ${slot.id}`
+        );
+        slot.resetSourceState();
+      }
+    }
+
+    this.slotsActiveInLastMediaRequest = activeSlots;
+  }
+
+  private sendRequests() {
+    const wcmeMediaRequests: MC.MediaRequest[] = [];
+
+    // todo: check how many streams we're asking for and what resolution and introduce some limits (spark-377701)
+    const maxPayloadBitsPerSecond = 10 * 1000 * 1000;
+
+    // map all the client media requests to wcme media requests
+    Object.values(this.clientRequests).forEach((mr) => {
+      wcmeMediaRequests.push(
+        new MC.MediaRequest(
+          mr.policyInfo.policy === 'active-speaker'
+            ? MC.Policy.ActiveSpeaker
+            : MC.Policy.ReceiverSelected,
+          mr.policyInfo.policy === 'active-speaker'
+            ? new MC.ActiveSpeakerInfo(
+                mr.policyInfo.priority,
+                mr.policyInfo.crossPriorityDuplication,
+                mr.policyInfo.crossPolicyDuplication,
+                mr.policyInfo.preferLiveVideo
+              )
+            : new MC.ReceiverSelectedInfo(mr.policyInfo.csi),
+          mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
+          maxPayloadBitsPerSecond,
+          mr.codecInfo && [
+            new MC.CodecInfo(
+              0x80,
+              new MC.H264Codec(
+                mr.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs,
+                mr.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps,
+                mr.codecInfo.maxMbps || CODEC_DEFAULTS.h264.maxMbps,
+                mr.codecInfo.maxWidth,
+                mr.codecInfo.maxHeight
+              )
+            ),
+          ]
+        )
+      );
+    });
+
+    this.sendMediaRequestsCallback(wcmeMediaRequests);
+
+    this.resetInactiveReceiveSlots();
+  }
+
+  public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {
+    // eslint-disable-next-line no-plusplus
+    const newId = `${this.counter++}`;
+
+    this.clientRequests[newId] = mediaRequest;
+
+    if (commit) {
+      this.commit();
+    }
+
+    return newId;
+  }
+
+  public cancelRequest(requestId: MediaRequestId, commit = true) {
+    delete this.clientRequests[requestId];
+
+    if (commit) {
+      this.commit();
+    }
+  }
+
+  public commit() {
+    return this.sendRequests();
+  }
+
+  public reset() {
+    this.clientRequests = {};
+    this.slotsActiveInLastMediaRequest = {};
+  }
+}

package/src/multistream/multistreamMedia.ts

@@ -0,0 +1,92 @@
+/* eslint-disable import/prefer-default-export */
+
+import {AUDIO, VIDEO} from '../constants';
+import createMuteState from '../meeting/muteState';
+import Meeting from '../meeting';
+
+/**
+ * Class wrapping all the multistream specific APIs that need to be exposed at meeting level.
+ *
+ */
+export class MultistreamMedia {
+  private meeting: Meeting;
+
+  /**
+   * Constructor
+   * @param {Meeting} meeting
+   */
+  constructor(meeting: Meeting) {
+    this.meeting = meeting;
+  }
+
+  /**
+   * throws if we don't have a media connection created
+   */
+  private checkMediaConnection() {
+    if (this.meeting?.mediaProperties?.webrtcMediaConnection) {
+      return;
+    }
+    throw new Error('Webrtc media connection is missing');
+  }
+
+  /**
+   * Publishes a local track in the meeting
+   *
+   * @param {MediaStreamTrack} track
+   * @returns {Promise}
+   */
+  publishTrack(track: MediaStreamTrack): Promise<void> {
+    this.checkMediaConnection();
+
+    /* todo: for now we don't support screen share (waiting for server to support bundling, see SPARK-377812)
+       for sharing:
+          we have to call meeting.stopFloorRequest() before unpublishing a track
+          we have to call meeting.share() after publishing a track
+    */
+
+    // todo: depending on how muting is done with Local tracks, this code here might need to change...
+
+    if (track.kind === 'audio') {
+      this.meeting.setLocalAudioTrack(track);
+      this.meeting.mediaProperties.mediaDirection.sendAudio = true;
+
+      // audio state could be undefined if you have not sent audio before
+      this.meeting.audio =
+        this.meeting.audio ||
+        createMuteState(AUDIO, this.meeting, this.meeting.mediaProperties.mediaDirection);
+    } else if (track.kind === 'video') {
+      this.meeting.setLocalVideoTrack(track);
+      this.meeting.mediaProperties.mediaDirection.sendVideo = true;
+
+      // video state could be undefined if you have not sent video before
+      this.meeting.video =
+        this.meeting.video ||
+        createMuteState(VIDEO, this.meeting, this.meeting.mediaProperties.mediaDirection);
+    }
+
+    return this.meeting.mediaProperties.webrtcMediaConnection.publishTrack(track);
+  }
+
+  /**
+   * Unpublishes a local track in the meeting
+   *
+   * @param {MediaStreamTrack} track
+   * @returns {Promise}
+   */
+  unpublishTrack(track: MediaStreamTrack): Promise<void> {
+    // todo: see todos in publishTrack() - they all apply here too:
+    // screen sharing - SPARK-377812
+    // muting etc
+
+    if (track.kind === 'audio') {
+      this.meeting.setLocalVideoTrack(null);
+      this.meeting.mediaProperties.mediaDirection.sendAudio = false;
+    } else if (track.kind === 'video') {
+      this.meeting.setLocalAudioTrack(null);
+      this.meeting.mediaProperties.mediaDirection.sendVideo = false;
+    }
+    this.checkMediaConnection();
+
+    return this.meeting.mediaProperties.webrtcMediaConnection.unpublishTrack(track);
+  }
+}

package/src/multistream/receiveSlot.ts

@@ -0,0 +1,141 @@
+import {MediaConnection as MC} from '@webex/internal-media-core';
+
+import LoggerProxy from '../common/logs/logger-proxy';
+import EventsScope from '../common/events/events-scope';
+
+export const ReceiveSlotEvents = {
+  SourceUpdate: 'sourceUpdate',
+};
+
+export type SourceState = MC.SourceState;
+export type CSI = number;
+export type MemberId = string;
+export type ReceiveSlotId = string;
+
+let receiveSlotCounter = 0;
+
+export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
+
+/**
+ * Class representing a receive slot. A single receive slot is able to receive a single track
+ * for example some participant's main video or audio
+ */
+export class ReceiveSlot extends EventsScope {
+  private readonly mcReceiveSlot: MC.ReceiveSlot;
+
+  private readonly findMemberIdCallback: FindMemberIdCallback;
+
+  public readonly id: ReceiveSlotId;
+
+  public readonly mediaType: MC.MediaType;
+
+  #memberId?: MemberId;
+
+  #csi?: CSI;
+
+  #sourceState: MC.SourceState;
+
+  /**
+   * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
+   * to create any receive slots
+   *
+   * @param {MC.MediaType} mediaType
+   * @param {MC.ReceiveSlot} mcReceiveSlot
+   * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
+   */
+  constructor(
+    mediaType: MC.MediaType,
+    mcReceiveSlot: MC.ReceiveSlot,
+    findMemberIdCallback: FindMemberIdCallback
+  ) {
+    super();
+
+    receiveSlotCounter += 1;
+
+    this.findMemberIdCallback = findMemberIdCallback;
+    this.mediaType = mediaType;
+    this.mcReceiveSlot = mcReceiveSlot;
+    this.#sourceState = 'no source';
+    this.id = `r${receiveSlotCounter}`;
+
+    this.setupEventListeners();
+  }
+
+  /**
+   * Getter for memberId
+   */
+  public get memberId() {
+    return this.#memberId;
+  }
+
+  /**
+   * Getter for csi
+   */
+  public get csi() {
+    return this.#csi;
+  }
+
+  /**
+   * Getter for sourceState
+   */
+  public get sourceState() {
+    return this.#sourceState;
+  }
+
+  /**
+   * registers event handlers with the underlying ReceiveSlot
+   */
+  setupEventListeners() {
+    const scope = {
+      file: 'meeting/receiveSlot',
+      function: 'setupEventListeners',
+    };
+
+    this.mcReceiveSlot.on(
+      MC.ReceiveSlotEvents.SourceUpdate,
+      (state: MC.SourceState, csi?: number) => {
+        LoggerProxy.logger.log(
+          `ReceiveSlot#setupEventListeners --> got source update on receive slot ${this.id}, mediaType=${this.mediaType}, csi=${csi}, state=${state}`
+        );
+        this.#memberId = csi ? this.findMemberIdCallback(csi) : undefined;
+        this.#csi = csi;
+        this.#sourceState = state;
+
+        this.emit(scope, ReceiveSlotEvents.SourceUpdate, {
+          state: this.#sourceState,
+          csi: this.#csi,
+          memberId: this.#memberId,
+        });
+      }
+    );
+  }
+
+  /**
+   * The MediaStream object associated with this slot.
+   *
+   * @returns {MediaStream} The MediaStreamTrack.
+   */
+  get stream(): MediaStream {
+    return this.mcReceiveSlot.stream;
+  }
+
+  /**
+   * The underlying WCME receive slot
+   */
+  get wcmeReceiveSlot(): MC.ReceiveSlot {
+    return this.mcReceiveSlot;
+  }
+
+  /**
+   * Resets the source state to the default 'no source' value.
+   * This function should be called on receive slots that are
+   * no longer part of a media request. It's needed because WCME
+   * does not send any more events on such slots, so the sourceState
+   * value would not represent the truth anymore.
+   */
+  public resetSourceState() {
+    this.#sourceState = 'no source';
+    this.#csi = undefined;
+    this.#memberId = undefined;
+  }
+}

package/src/multistream/receiveSlotManager.ts

@@ -0,0 +1,142 @@
+/* eslint-disable import/prefer-default-export */
+import {MediaConnection as MC} from '@webex/internal-media-core';
+
+import LoggerProxy from '../common/logs/logger-proxy';
+import Meeting from '../meeting';
+
+import {CSI, ReceiveSlot} from './receiveSlot';
+
+/**
+ * Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted,
+ * so this manager has a pool in order to re-use the slots that were released earlier.
+ */
+export class ReceiveSlotManager {
+  private allocatedSlots: {[key in MC.MediaType]: ReceiveSlot[]};
+
+  private freeSlots: {[key in MC.MediaType]: ReceiveSlot[]};
+
+  private meeting: Meeting;
+
+  /**
+   * Constructor
+   * @param {Meeting} meeting
+   */
+  constructor(meeting) {
+    this.allocatedSlots = {
+      [MC.MediaType.AudioMain]: [],
+      [MC.MediaType.VideoMain]: [],
+      [MC.MediaType.AudioSlides]: [],
+      [MC.MediaType.VideoSlides]: [],
+    };
+    this.freeSlots = {
+      [MC.MediaType.AudioMain]: [],
+      [MC.MediaType.VideoMain]: [],
+      [MC.MediaType.AudioSlides]: [],
+      [MC.MediaType.VideoSlides]: [],
+    };
+    this.meeting = meeting;
+  }
+
+  /**
+   * Creates a new receive slot or returns one from the existing pool of free slots
+   *
+   * @param {MC.MediaType} mediaType
+   * @returns {Promise<ReceiveSlot>}
+   */
+  async allocateSlot(mediaType: MC.MediaType): Promise<ReceiveSlot> {
+    if (!this.meeting?.mediaProperties?.webrtcMediaConnection) {
+      return Promise.reject(new Error('Webrtc media connection is missing'));
+    }
+
+    // try to use one of the free ones
+    const availableSlot = this.freeSlots[mediaType].pop();
+
+    if (availableSlot) {
+      this.allocatedSlots[mediaType].push(availableSlot);
+
+      LoggerProxy.logger.log(`receive slot re-used: ${availableSlot.id}`);
+
+      return availableSlot;
+    }
+
+    // we have to create a new one
+    const wcmeReceiveSlot =
+      await this.meeting.mediaProperties.webrtcMediaConnection.createReceiveSlot(mediaType);
+
+    const receiveSlot = new ReceiveSlot(
+      mediaType,
+      wcmeReceiveSlot,
+      (csi: CSI) => this.meeting.members.findMemberByCsi(csi)?.id
+    );
+
+    this.allocatedSlots[mediaType].push(receiveSlot);
+    LoggerProxy.logger.log(`new receive slot allocated: ${receiveSlot.id}`);
+
+    return receiveSlot;
+  }
+
+  /**
+   * Releases the slot back to the pool so it can be re-used by others in the future
+   * @param {ReceiveSlot} slot
+   */
+  releaseSlot(slot: ReceiveSlot) {
+    const idx = this.allocatedSlots[slot.mediaType].findIndex(
+      (allocatedSlot) => allocatedSlot === slot
+    );
+
+    if (idx >= 0) {
+      this.allocatedSlots[slot.mediaType].splice(idx, 1);
+      this.freeSlots[slot.mediaType].push(slot);
+      LoggerProxy.logger.log(`receive slot released: ${slot.id}`);
+    } else {
+      LoggerProxy.logger.warn(
+        'ReceiveSlotManager#releaseSlot --> trying to release a slot that is not managed by this ReceiveSlotManager'
+      );
+    }
+  }
+
+  /**
+   * Resets the slot manager - this method should be called when the media connection is torn down
+   */
+  reset() {
+    this.allocatedSlots = {
+      [MC.MediaType.AudioMain]: [],
+      [MC.MediaType.VideoMain]: [],
+      [MC.MediaType.AudioSlides]: [],
+      [MC.MediaType.VideoSlides]: [],
+    };
+    this.freeSlots = {
+      [MC.MediaType.AudioMain]: [],
+      [MC.MediaType.VideoMain]: [],
+      [MC.MediaType.AudioSlides]: [],
+      [MC.MediaType.VideoSlides]: [],
+    };
+  }
+
+  /**
+   * Returns statistics about the managed slots
+   *
+   * @returns {Object}
+   */
+  getStats() {
+    const numAllocatedSlots = {};
+    const numFreeSlots = {};
+
+    Object.keys(this.allocatedSlots).forEach((key) => {
+      if (this.allocatedSlots[key].length > 0) {
+        numAllocatedSlots[key] = this.allocatedSlots[key].length;
+      }
+    });
+
+    Object.keys(this.freeSlots).forEach((key) => {
+      if (this.freeSlots[key].length > 0) {
+        numFreeSlots[key] = this.freeSlots[key].length;
+      }
+    });
+
+    return {
+      numAllocatedSlots,
+      numFreeSlots,
+    };
+  }
+}