@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

package/src/multistream/receiveSlot.ts

@@ -1,13 +1,20 @@
-import {MediaConnection as MC} from '@webex/internal-media-core';
+/* eslint-disable valid-jsdoc */
+import {
+  MediaType,
+  ReceiveSlot as WcmeReceiveSlot,
+  ReceiveSlotEvents as WcmeReceiveSlotEvents,
+  StreamState,
+} from '@webex/internal-media-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsScope from '../common/events/events-scope';
 
 export const ReceiveSlotEvents = {
   SourceUpdate: 'sourceUpdate',
+  MaxFsUpdate: 'maxFsUpdate',
 };
 
-export type SourceState = MC.SourceState;
+export type {StreamState} from '@webex/internal-media-core';
 export type CSI = number;
 export type MemberId = string;
 export type ReceiveSlotId = string;
@@ -21,31 +28,31 @@ export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
  * for example some participant's main video or audio
  */
 export class ReceiveSlot extends EventsScope {
-  private readonly mcReceiveSlot: MC.ReceiveSlot;
+  private readonly mcReceiveSlot: WcmeReceiveSlot;
 
   private readonly findMemberIdCallback: FindMemberIdCallback;
 
   public readonly id: ReceiveSlotId;
 
-  public readonly mediaType: MC.MediaType;
+  public readonly mediaType: MediaType;
 
   #memberId?: MemberId;
 
   #csi?: CSI;
 
-  #sourceState: MC.SourceState;
+  #sourceState: StreamState;
 
   /**
    * 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 {MediaType} mediaType
+   * @param {ReceiveSlot} mcReceiveSlot
    * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
    */
   constructor(
-    mediaType: MC.MediaType,
-    mcReceiveSlot: MC.ReceiveSlot,
+    mediaType: MediaType,
+    mcReceiveSlot: WcmeReceiveSlot,
     findMemberIdCallback: FindMemberIdCallback
   ) {
     super();
@@ -75,6 +82,25 @@ export class ReceiveSlot extends EventsScope {
     return this.#csi;
   }
 
+  /**
+   * Set the max frame size for this slot
+   * @param newFs frame size
+   */
+  public setMaxFs(newFs) {
+    // emit event for media request manager to listen to
+
+    this.emit(
+      {
+        file: 'meeting/receiveSlot',
+        function: 'findMemberId',
+      },
+      ReceiveSlotEvents.MaxFsUpdate,
+      {
+        maxFs: newFs,
+      }
+    );
+  }
+
   /**
    * Getter for sourceState
    */
@@ -85,15 +111,15 @@ export class ReceiveSlot extends EventsScope {
   /**
    * registers event handlers with the underlying ReceiveSlot
    */
-  setupEventListeners() {
+  private setupEventListeners() {
     const scope = {
       file: 'meeting/receiveSlot',
       function: 'setupEventListeners',
     };
 
     this.mcReceiveSlot.on(
-      MC.ReceiveSlotEvents.SourceUpdate,
-      (state: MC.SourceState, csi?: number) => {
+      WcmeReceiveSlotEvents.SourceUpdate,
+      (state: StreamState, csi?: number) => {
         LoggerProxy.logger.log(
           `ReceiveSlot#setupEventListeners --> got source update on receive slot ${this.id}, mediaType=${this.mediaType}, csi=${csi}, state=${state}`
         );
@@ -110,6 +136,36 @@ export class ReceiveSlot extends EventsScope {
     );
   }
 
+  /** Tries to find the member id for this receive slot if it hasn't got one */
+  public findMemberId() {
+    if (this.#memberId === undefined && this.#csi) {
+      this.#memberId = this.findMemberIdCallback(this.#csi);
+
+      if (this.#memberId) {
+        // if we found the memberId, simulate source update so that the client app knows that something's changed
+        this.emit(
+          {
+            file: 'meeting/receiveSlot',
+            function: 'findMemberId',
+          },
+          ReceiveSlotEvents.SourceUpdate,
+          {
+            state: this.#sourceState,
+            csi: this.#csi,
+            memberId: this.#memberId,
+          }
+        );
+      }
+    }
+  }
+
+  /**
+   * @returns {string} a log message used to identify the receive slot
+   */
+  public get logString() {
+    return `ReceiveSlot - ${this.id}: ${JSON.stringify(this.mcReceiveSlot.id)}`;
+  }
+
   /**
    * The MediaStream object associated with this slot.
    *
@@ -122,20 +178,7 @@ export class ReceiveSlot extends EventsScope {
   /**
    * The underlying WCME receive slot
    */
-  get wcmeReceiveSlot(): MC.ReceiveSlot {
+  get wcmeReceiveSlot(): WcmeReceiveSlot {
     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

@@ -1,76 +1,76 @@
+/* eslint-disable valid-jsdoc */
 /* eslint-disable import/prefer-default-export */
-import {MediaConnection as MC} from '@webex/internal-media-core';
-
+import {MediaType, ReceiveSlot as WcmeReceiveSlot} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
-import Meeting from '../meeting';
 
-import {CSI, ReceiveSlot} from './receiveSlot';
+import {FindMemberIdCallback, ReceiveSlot} from './receiveSlot';
+
+export type CreateSlotCallback = (mediaType: MediaType) => Promise<WcmeReceiveSlot>;
+
+export type {CSI, FindMemberIdCallback} 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 allocatedSlots: {[key in MediaType]: ReceiveSlot[]};
 
-  private freeSlots: {[key in MC.MediaType]: ReceiveSlot[]};
+  private freeSlots: {[key in MediaType]: ReceiveSlot[]};
 
-  private meeting: Meeting;
+  private createSlotCallback: CreateSlotCallback;
+
+  private findMemberIdByCsiCallback: FindMemberIdCallback;
 
   /**
    * Constructor
    * @param {Meeting} meeting
    */
-  constructor(meeting) {
+  constructor(
+    createSlotCallback: CreateSlotCallback,
+    findMemberIdByCsiCallback: FindMemberIdCallback
+  ) {
     this.allocatedSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
     this.freeSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
-    this.meeting = meeting;
+    this.createSlotCallback = createSlotCallback;
+    this.findMemberIdByCsiCallback = findMemberIdByCsiCallback;
   }
 
   /**
    * Creates a new receive slot or returns one from the existing pool of free slots
    *
-   * @param {MC.MediaType} mediaType
+   * @param {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'));
-    }
-
+  async allocateSlot(mediaType: MediaType): Promise<ReceiveSlot> {
     // 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}`);
+      LoggerProxy.logger.log(`${mediaType}: 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 wcmeReceiveSlot = await this.createSlotCallback(mediaType);
 
-    const receiveSlot = new ReceiveSlot(
-      mediaType,
-      wcmeReceiveSlot,
-      (csi: CSI) => this.meeting.members.findMemberByCsi(csi)?.id
-    );
+    const receiveSlot = new ReceiveSlot(mediaType, wcmeReceiveSlot, this.findMemberIdByCsiCallback);
 
     this.allocatedSlots[mediaType].push(receiveSlot);
-    LoggerProxy.logger.log(`new receive slot allocated: ${receiveSlot.id}`);
+    LoggerProxy.logger.log(`${mediaType}: new receive slot allocated: ${receiveSlot.id}`);
 
     return receiveSlot;
   }
@@ -87,10 +87,10 @@ export class ReceiveSlotManager {
     if (idx >= 0) {
       this.allocatedSlots[slot.mediaType].splice(idx, 1);
       this.freeSlots[slot.mediaType].push(slot);
-      LoggerProxy.logger.log(`receive slot released: ${slot.id}`);
+      LoggerProxy.logger.log(`${slot.mediaType}: receive slot released: ${slot.id}`);
     } else {
       LoggerProxy.logger.warn(
-        'ReceiveSlotManager#releaseSlot --> trying to release a slot that is not managed by this ReceiveSlotManager'
+        `ReceiveSlotManager#releaseSlot --> trying to release a ${slot.mediaType}} slot that is not managed by this ReceiveSlotManager`
       );
     }
   }
@@ -100,16 +100,16 @@ export class ReceiveSlotManager {
    */
   reset() {
     this.allocatedSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
     this.freeSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
   }
 
@@ -139,4 +139,28 @@ export class ReceiveSlotManager {
       numFreeSlots,
     };
   }
+
+  /**
+   * Tries to find the member id on all allocated receive slots
+   * This function should be called when new members are added to the meeting.
+   */
+  updateMemberIds() {
+    Object.keys(this.allocatedSlots).forEach((key) => {
+      this.allocatedSlots[key].forEach((slot: ReceiveSlot) => {
+        slot.findMemberId();
+      });
+    });
+  }
+
+  /**
+   * Find a receive slot by a ssrc.
+   *
+   * @param ssrc - The ssrc of the receive slot to find.
+   * @returns - The receive slot with this ssrc, undefined if not found.
+   */
+  findReceiveSlotBySsrc(ssrc: number): ReceiveSlot | undefined {
+    return Object.values(this.allocatedSlots)
+      .flat()
+      .find((r) => ssrc && r.wcmeReceiveSlot?.id?.ssrc === ssrc);
+  }
 }

package/src/multistream/remoteMedia.ts

@@ -1,4 +1,5 @@
 /* eslint-disable valid-jsdoc */
+import {MediaType, StreamState} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsScope from '../common/events/events-scope';
 
@@ -7,6 +8,7 @@ import {CSI, ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
 
 export const RemoteMediaEvents = {
   SourceUpdate: ReceiveSlotEvents.SourceUpdate,
+  Stopped: 'stopped',
 };
 
 export type RemoteVideoResolution =
@@ -55,7 +57,7 @@ export function getMaxFs(paneSize: RemoteVideoResolution): number {
 }
 
 type Options = {
-  resolution?: RemoteVideoResolution; // applies only to groups of type MC.MediaType.VideoMain and MC.MediaType.VideoSlides
+  resolution?: RemoteVideoResolution; // applies only to groups of type MediaType.VideoMain and MediaType.VideoSlides
 };
 
 export type RemoteMediaId = string;
@@ -100,6 +102,31 @@ export class RemoteMedia extends EventsScope {
     this.id = `RM${remoteMediaCounter}-${this.receiveSlot.id}`;
   }
 
+  /**
+   * Supply the width and height of the video element
+   * to restrict the requested resolution to this size
+   * @param width width of the video element
+   * @param height height of the video element
+   */
+  public setSizeHint(width, height) {
+    // only base on height for now
+    let fs: number;
+
+    if (height < 135) {
+      fs = 60;
+    } else if (height < 270) {
+      fs = 240;
+    } else if (height < 540) {
+      fs = 920;
+    } else if (height <= 720) {
+      fs = 3600;
+    } else {
+      fs = 8192;
+    }
+
+    this.receiveSlot?.setMaxFs(fs);
+  }
+
   /**
    * Invalidates the remote media by clearing the reference to a receive slot and
    * cancelling the media request.
@@ -108,10 +135,18 @@ export class RemoteMedia extends EventsScope {
    * @param {boolean} commit - whether to commit the cancellation of the media request
    * @internal
    */
-  public stop(commit: boolean = true) {
+  public stop(commit = true) {
     this.cancelMediaRequest(commit);
     this.receiveSlot?.removeAllListeners();
     this.receiveSlot = undefined;
+    this.emit(
+      {
+        file: 'multistream/remoteMedia',
+        function: 'stop',
+      },
+      RemoteMediaEvents.Stopped,
+      {}
+    );
   }
 
   /**
@@ -164,7 +199,7 @@ export class RemoteMedia extends EventsScope {
   private setupEventListeners() {
     if (this.receiveSlot) {
       const scope = {
-        file: 'meeting/remoteMedia',
+        file: 'multistream/remoteMedia',
         function: 'setupEventListeners',
       };
 
@@ -177,7 +212,7 @@ export class RemoteMedia extends EventsScope {
   /**
    * Getter for mediaType
    */
-  public get mediaType() {
+  public get mediaType(): MediaType {
     return this.receiveSlot?.mediaType;
   }
 
@@ -198,7 +233,7 @@ export class RemoteMedia extends EventsScope {
   /**
    * Getter for source state
    */
-  public get sourceState() {
+  public get sourceState(): StreamState {
     return this.receiveSlot?.sourceState;
   }
 

package/src/multistream/remoteMediaGroup.ts

@@ -1,6 +1,8 @@
 /* eslint-disable valid-jsdoc */
 /* eslint-disable require-jsdoc */
 /* eslint-disable import/prefer-default-export */
+import {forEach} from 'lodash';
+import {NamedMediaGroup} from '@webex/json-multistream';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {getMaxFs, RemoteMedia, RemoteVideoResolution} from './remoteMedia';
@@ -8,8 +10,9 @@ import {MediaRequestId, MediaRequestManager} from './mediaRequestManager';
 import {CSI, ReceiveSlot} from './receiveSlot';
 
 type Options = {
-  resolution?: RemoteVideoResolution; // applies only to groups of type MC.MediaType.VideoMain and MC.MediaType.VideoSlides
-  preferLiveVideo?: boolean; // applies only to groups of type MC.MediaType.VideoMain and MC.MediaType.VideoSlides
+  resolution?: RemoteVideoResolution; // applies only to groups of type MediaType.VideoMain and MediaType.VideoSlides
+  preferLiveVideo?: boolean; // applies only to groups of type MediaType.VideoMain and MediaType.VideoSlides
+  namedMediaGroup?: NamedMediaGroup; // applies only to named media groups for audio
 };
 
 export class RemoteMediaGroup {
@@ -62,9 +65,57 @@ export class RemoteMediaGroup {
       // return a shallow copy so that the client cannot modify this.pinnedRemoteMedia array
       return [...this.pinnedRemoteMedia];
     }
+
     return [...this.unpinnedRemoteMedia, ...this.pinnedRemoteMedia];
   }
 
+  /**
+   * Sets CSIs for multiple RemoteMedia instances belonging to this RemoteMediaGroup.
+   * For each entry in the remoteMediaCsis array:
+   * - if csi is specified, the RemoteMedia instance is pinned to that CSI
+   * - if csi is undefined, the RemoteMedia instance is unpinned
+   * @internal
+   */
+  public setActiveSpeakerCsis(
+    remoteMediaCsis: {remoteMedia: RemoteMedia; csi?: number}[],
+    commit = true
+  ): void {
+    forEach(remoteMediaCsis, ({csi, remoteMedia}) => {
+      if (csi) {
+        if (!(this.pinnedRemoteMedia.indexOf(remoteMedia) >= 0)) {
+          const unpinId = this.unpinnedRemoteMedia.indexOf(remoteMedia);
+          if (unpinId >= 0) {
+            this.unpinnedRemoteMedia.splice(unpinId, 1);
+            this.pinnedRemoteMedia.push(remoteMedia);
+          } else {
+            throw new Error(
+              `failed to pin a remote media object ${remoteMedia.id}, because it is not found in this remote media group`
+            );
+          }
+        }
+        remoteMedia.sendMediaRequest(csi, false);
+      } else {
+        if (!(this.unpinnedRemoteMedia.indexOf(remoteMedia) >= 0)) {
+          const pinId = this.pinnedRemoteMedia.indexOf(remoteMedia);
+          if (pinId >= 0) {
+            this.pinnedRemoteMedia.splice(pinId, 1);
+            this.unpinnedRemoteMedia.push(remoteMedia);
+          } else {
+            throw new Error(
+              `failed to unpin a remote media object ${remoteMedia.id}, because it is not found in this remote media group`
+            );
+          }
+        }
+        remoteMedia.cancelMediaRequest(false);
+      }
+    });
+    this.cancelActiveSpeakerMediaRequest(false);
+    this.sendActiveSpeakerMediaRequest(false);
+    if (commit) {
+      this.mediaRequestManager.commit();
+    }
+  }
+
   /**
    * Pins a specific remote media instance to a specfic CSI, so the media will
    * no longer come from active speaker, but from that CSI.
@@ -150,6 +201,17 @@ export class RemoteMediaGroup {
     throw new Error(`remote media object ${remoteMedia.id} not found in the group`);
   }
 
+  /**
+   * setPreferLiveVideo - sets preferLiveVideo to true/false
+   * @internal
+   */
+  public setPreferLiveVideo(preferLiveVideo: boolean, commit: boolean) {
+    if (this.options.preferLiveVideo !== preferLiveVideo) {
+      this.options.preferLiveVideo = preferLiveVideo;
+      this.sendActiveSpeakerMediaRequest(commit);
+    }
+  }
+
   private sendActiveSpeakerMediaRequest(commit: boolean) {
     this.cancelActiveSpeakerMediaRequest(false);
 
@@ -161,6 +223,9 @@ export class RemoteMediaGroup {
           crossPriorityDuplication: false,
           crossPolicyDuplication: false,
           preferLiveVideo: !!this.options?.preferLiveVideo,
+          namedMediaGroups: this.options.namedMediaGroup?.value
+            ? [this.options?.namedMediaGroup]
+            : undefined,
         },
         receiveSlots: this.unpinnedRemoteMedia.map((remoteMedia) =>
           remoteMedia.getUnderlyingReceiveSlot()
@@ -181,6 +246,20 @@ export class RemoteMediaGroup {
     }
   }
 
+  /**
+   * setNamedMediaGroup - sets named media group type and value
+   * @internal
+   */
+  public setNamedMediaGroup(namedMediaGroup: NamedMediaGroup, commit: boolean) {
+    if (
+      this.options.namedMediaGroup.value !== namedMediaGroup.value ||
+      this.options.namedMediaGroup.type !== namedMediaGroup.type
+    ) {
+      this.options.namedMediaGroup = namedMediaGroup;
+      this.sendActiveSpeakerMediaRequest(commit);
+    }
+  }
+
   /**
    * Invalidates the remote media group by clearing the references to the receive slots
    * used by all remote media from that group and cancelling all media requests.
@@ -189,7 +268,7 @@ export class RemoteMediaGroup {
    * @param{boolean} commit whether to commit the cancellation of media requests
    * @internal
    */
-  public stop(commit: boolean = true) {
+  public stop(commit = true) {
     this.unpinnedRemoteMedia.forEach((remoteMedia) => remoteMedia.stop(false));
     this.pinnedRemoteMedia.forEach((remoteMedia) => remoteMedia.stop(false));
     this.cancelActiveSpeakerMediaRequest(false);