@webex/plugin-meetings 3.0.0-bnr.4 → 3.0.0-stream-classes.1

package/src/multistream/mediaRequestManager.ts

@@ -1,6 +1,6 @@
 /* eslint-disable require-jsdoc */
 import {
-  MediaRequest as WcmeMediaRequest,
+  StreamRequest,
   Policy,
   ActiveSpeakerInfo,
   ReceiverSelectedInfo,
@@ -9,7 +9,7 @@ import {
   getRecommendedMaxBitrateForFrameSize,
   RecommendedOpusBitrates,
 } from '@webex/internal-media-core';
-import {cloneDeep, debounce, isEmpty} from 'lodash';
+import {cloneDeepWith, debounce, isEmpty} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -47,6 +47,7 @@ export interface MediaRequest {
   receiveSlots: Array<ReceiveSlot>;
   codecInfo?: CodecInfo;
   preferredMaxFs?: number;
+  handleMaxFs?: ({maxFs}: {maxFs: number}) => void;
 }
 
 export type MediaRequestId = string;
@@ -65,13 +66,17 @@ type DegradationPreferences = {
   maxMacroblocksLimit: number;
 };
 
-type SendMediaRequestsCallback = (mediaRequests: WcmeMediaRequest[]) => void;
+type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
 type Kind = 'audio' | 'video';
 
 type Options = {
   degradationPreferences: DegradationPreferences;
   kind: Kind;
+  trimRequestsToNumOfSources: boolean; // if enabled, AS speaker requests will be trimmed based on the calls to setNumCurrentSources()
 };
+
+type ClientRequestsMap = {[key: MediaRequestId]: MediaRequest};
+
 export class MediaRequestManager {
   private sendMediaRequestsCallback: SendMediaRequestsCallback;
 
@@ -79,7 +84,7 @@ export class MediaRequestManager {
 
   private counter: number;
 
-  private clientRequests: {[key: MediaRequestId]: MediaRequest};
+  private clientRequests: ClientRequestsMap;
 
   private degradationPreferences: DegradationPreferences;
 
@@ -87,14 +92,21 @@ export class MediaRequestManager {
 
   private debouncedSourceUpdateListener: () => void;
 
-  private previousWCMEMediaRequests: Array<WcmeMediaRequest> = [];
+  private previousStreamRequests: Array<StreamRequest> = [];
+
+  private trimRequestsToNumOfSources: boolean;
+  private numTotalSources: number;
+  private numLiveSources: number;
 
   constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options) {
     this.sendMediaRequestsCallback = sendMediaRequestsCallback;
     this.counter = 0;
+    this.numLiveSources = 0;
+    this.numTotalSources = 0;
     this.clientRequests = {};
     this.degradationPreferences = options.degradationPreferences;
     this.kind = options.kind;
+    this.trimRequestsToNumOfSources = options.trimRequestsToNumOfSources;
     this.sourceUpdateListener = this.commit.bind(this);
     this.debouncedSourceUpdateListener = debounce(
       this.sourceUpdateListener,
@@ -107,8 +119,7 @@ export class MediaRequestManager {
     this.sendRequests(); // re-send requests after preferences are set
   }
 
-  private getDegradedClientRequests() {
-    const clientRequests = cloneDeep(this.clientRequests);
+  private getDegradedClientRequests(clientRequests: ClientRequestsMap) {
     const maxFsLimits = [
       getMaxFs('best'),
       getMaxFs('large'),
@@ -121,7 +132,7 @@ export class MediaRequestManager {
     // reduce max-fs until total macroblocks is below limit
     for (let i = 0; i < maxFsLimits.length; i += 1) {
       let totalMacroblocksRequested = 0;
-      Object.entries(clientRequests).forEach(([id, mr]) => {
+      Object.values(clientRequests).forEach((mr) => {
         if (mr.codecInfo) {
           mr.codecInfo.maxFs = Math.min(
             mr.preferredMaxFs || CODEC_DEFAULTS.h264.maxFs,
@@ -129,9 +140,7 @@ export class MediaRequestManager {
             maxFsLimits[i]
           );
           // we only consider sources with "live" state
-          const slotsWithLiveSource = this.clientRequests[id].receiveSlots.filter(
-            (rs) => rs.sourceState === 'live'
-          );
+          const slotsWithLiveSource = mr.receiveSlots.filter((rs) => rs.sourceState === 'live');
           totalMacroblocksRequested += mr.codecInfo.maxFs * slotsWithLiveSource.length;
         }
       });
@@ -148,37 +157,35 @@ export class MediaRequestManager {
         );
       }
     }
-
-    return clientRequests;
   }
 
   /**
-   * Returns true if two media requests are the same, false otherwise.
+   * Returns true if two stream requests are the same, false otherwise.
    *
-   * @param {WcmeMediaRequest} mediaRequestA - Media request A for comparison.
-   * @param {WcmeMediaRequest} mediaRequestB - Media request B for comparison.
+   * @param {StreamRequest} streamRequestA - Stream request A for comparison.
+   * @param {StreamRequest} streamRequestB - Stream request B for comparison.
    * @returns {boolean} - Whether they are equal.
    */
   // eslint-disable-next-line class-methods-use-this
-  public isEqual(mediaRequestA: WcmeMediaRequest, mediaRequestB: WcmeMediaRequest) {
+  public isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest) {
     return (
-      JSON.stringify(mediaRequestA._toJmpScrRequest()) ===
-      JSON.stringify(mediaRequestB._toJmpScrRequest())
+      JSON.stringify(streamRequestA._toJmpStreamRequest()) ===
+      JSON.stringify(streamRequestB._toJmpStreamRequest())
     );
   }
 
   /**
-   * Compares new media requests to previous ones and determines
+   * Compares new stream requests to previous ones and determines
    * if they are the same.
    *
-   * @param {WcmeMediaRequest[]} newRequests - Array with new requests.
+   * @param {StreamRequest[]} newRequests - Array with new requests.
    * @returns {boolean} - True if they are equal, false otherwise.
    */
-  private checkIsNewRequestsEqualToPrev(newRequests: WcmeMediaRequest[]) {
+  private checkIsNewRequestsEqualToPrev(newRequests: StreamRequest[]) {
     return (
-      !isEmpty(this.previousWCMEMediaRequests) &&
-      this.previousWCMEMediaRequests.length === newRequests.length &&
-      this.previousWCMEMediaRequests.every((req, idx) => this.isEqual(req, newRequests[idx]))
+      !isEmpty(this.previousStreamRequests) &&
+      this.previousStreamRequests.length === newRequests.length &&
+      this.previousStreamRequests.every((req, idx) => this.isEqual(req, newRequests[idx]))
     );
   }
 
@@ -222,57 +229,151 @@ export class MediaRequestManager {
   }
 
   /**
-   * Clears the previous media requests.
+   * Clears the previous stream requests.
    *
    * @returns {void}
    */
   public clearPreviousRequests(): void {
-    this.previousWCMEMediaRequests = [];
+    this.previousStreamRequests = [];
+  }
+
+  /** Modifies the passed in clientRequests and makes sure that in total they don't ask
+   *  for more streams than there are available.
+   *
+   * @param {Object} clientRequests
+   * @returns {void}
+   */
+  private trimRequests(clientRequests: ClientRequestsMap) {
+    const preferLiveVideo = this.getPreferLiveVideo();
+
+    if (!this.trimRequestsToNumOfSources) {
+      return;
+    }
+
+    // preferLiveVideo being undefined means that there are no active-speaker requests so we don't need to do any trimming
+    if (preferLiveVideo === undefined) {
+      return;
+    }
+
+    let numStreamsAvailable = preferLiveVideo ? this.numLiveSources : this.numTotalSources;
+
+    Object.values(clientRequests)
+      .sort((a, b) => {
+        // we have to count how many streams we're asking for
+        // and should not ask for more than numStreamsAvailable in total,
+        // so we might need to trim active-speaker requests and first ones to trim should be
+        // the ones with lowest priority
+
+        // receiver-selected requests have priority over active-speakers
+        if (a.policyInfo.policy === 'receiver-selected') {
+          return -1;
+        }
+        if (b.policyInfo.policy === 'receiver-selected') {
+          return 1;
+        }
+
+        // and active-speakers are sorted by descending priority
+        return b.policyInfo.priority - a.policyInfo.priority;
+      })
+      .forEach((request) => {
+        // we only trim active-speaker requests
+        if (request.policyInfo.policy === 'active-speaker') {
+          const trimmedCount = Math.min(numStreamsAvailable, request.receiveSlots.length);
+
+          request.receiveSlots.length = trimmedCount;
+
+          numStreamsAvailable -= trimmedCount;
+        } else {
+          numStreamsAvailable -= request.receiveSlots.length;
+        }
+
+        if (numStreamsAvailable < 0) {
+          numStreamsAvailable = 0;
+        }
+      });
+  }
+
+  private getPreferLiveVideo(): boolean | undefined {
+    let preferLiveVideo;
+
+    Object.values(this.clientRequests).forEach((mr) => {
+      if (mr.policyInfo.policy === 'active-speaker') {
+        // take the value from first encountered active speaker request
+        if (preferLiveVideo === undefined) {
+          preferLiveVideo = mr.policyInfo.preferLiveVideo;
+        }
+
+        if (mr.policyInfo.preferLiveVideo !== preferLiveVideo) {
+          throw new Error(
+            'a mix of active-speaker groups with different values for preferLiveVideo is not supported'
+          );
+        }
+      }
+    });
+
+    return preferLiveVideo;
+  }
+
+  private cloneClientRequests(): ClientRequestsMap {
+    // we clone the client requests but without cloning the ReceiveSlots that they reference
+    return cloneDeepWith(this.clientRequests, (value, key) => {
+      if (key === 'receiveSlots') {
+        return [...value];
+      }
+
+      return undefined;
+    });
   }
 
   private sendRequests() {
-    const wcmeMediaRequests: WcmeMediaRequest[] = [];
+    const streamRequests: StreamRequest[] = [];
+
+    // clone the requests so that any modifications we do to them don't affect the original ones
+    const clientRequests = this.cloneClientRequests();
 
-    const clientRequests = this.getDegradedClientRequests();
+    this.trimRequests(clientRequests);
+    this.getDegradedClientRequests(clientRequests);
 
-    // map all the client media requests to wcme media requests
+    // map all the client media requests to wcme stream requests
     Object.values(clientRequests).forEach((mr) => {
-      wcmeMediaRequests.push(
-        new WcmeMediaRequest(
-          mr.policyInfo.policy === 'active-speaker'
-            ? Policy.ActiveSpeaker
-            : Policy.ReceiverSelected,
-          mr.policyInfo.policy === 'active-speaker'
-            ? new ActiveSpeakerInfo(
-                mr.policyInfo.priority,
-                mr.policyInfo.crossPriorityDuplication,
-                mr.policyInfo.crossPolicyDuplication,
-                mr.policyInfo.preferLiveVideo
-              )
-            : new ReceiverSelectedInfo(mr.policyInfo.csi),
-          mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
-          this.getMaxPayloadBitsPerSecond(mr),
-          mr.codecInfo && [
-            new WcmeCodecInfo(
-              0x80,
-              new H264Codec(
-                mr.codecInfo.maxFs,
-                mr.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps,
-                this.getH264MaxMbps(mr),
-                mr.codecInfo.maxWidth,
-                mr.codecInfo.maxHeight
-              )
-            ),
-          ]
-        )
-      );
+      if (mr.receiveSlots.length > 0) {
+        streamRequests.push(
+          new StreamRequest(
+            mr.policyInfo.policy === 'active-speaker'
+              ? Policy.ActiveSpeaker
+              : Policy.ReceiverSelected,
+            mr.policyInfo.policy === 'active-speaker'
+              ? new ActiveSpeakerInfo(
+                  mr.policyInfo.priority,
+                  mr.policyInfo.crossPriorityDuplication,
+                  mr.policyInfo.crossPolicyDuplication,
+                  mr.policyInfo.preferLiveVideo
+                )
+              : new ReceiverSelectedInfo(mr.policyInfo.csi),
+            mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
+            this.getMaxPayloadBitsPerSecond(mr),
+            mr.codecInfo && [
+              new WcmeCodecInfo(
+                0x80,
+                new H264Codec(
+                  mr.codecInfo.maxFs,
+                  mr.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps,
+                  this.getH264MaxMbps(mr),
+                  mr.codecInfo.maxWidth,
+                  mr.codecInfo.maxHeight
+                )
+              ),
+            ]
+          )
+        );
+      }
     });
 
     //! IMPORTANT: this is only a temporary fix. This will soon be done in the jmp layer (@webex/json-multistream)
     // https://jira-eng-gpk2.cisco.com/jira/browse/WEBEX-326713
-    if (!this.checkIsNewRequestsEqualToPrev(wcmeMediaRequests)) {
-      this.sendMediaRequestsCallback(wcmeMediaRequests);
-      this.previousWCMEMediaRequests = wcmeMediaRequests;
+    if (!this.checkIsNewRequestsEqualToPrev(streamRequests)) {
+      this.sendMediaRequestsCallback(streamRequests);
+      this.previousStreamRequests = streamRequests;
       LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
     } else {
       LoggerProxy.logger.info(
@@ -287,12 +388,15 @@ export class MediaRequestManager {
 
     this.clientRequests[newId] = mediaRequest;
 
+    const eventHandler = ({maxFs}) => {
+      mediaRequest.preferredMaxFs = maxFs;
+      this.debouncedSourceUpdateListener();
+    };
+    mediaRequest.handleMaxFs = eventHandler;
+
     mediaRequest.receiveSlots.forEach((rs) => {
       rs.on(ReceiveSlotEvents.SourceUpdate, this.sourceUpdateListener);
-      rs.on(ReceiveSlotEvents.MaxFsUpdate, ({maxFs}) => {
-        mediaRequest.preferredMaxFs = maxFs;
-        this.debouncedSourceUpdateListener();
-      });
+      rs.on(ReceiveSlotEvents.MaxFsUpdate, mediaRequest.handleMaxFs);
     });
 
     if (commit) {
@@ -303,8 +407,11 @@ export class MediaRequestManager {
   }
 
   public cancelRequest(requestId: MediaRequestId, commit = true) {
-    this.clientRequests[requestId]?.receiveSlots.forEach((rs) => {
+    const mediaRequest = this.clientRequests[requestId];
+
+    mediaRequest?.receiveSlots.forEach((rs) => {
       rs.off(ReceiveSlotEvents.SourceUpdate, this.sourceUpdateListener);
+      rs.off(ReceiveSlotEvents.MaxFsUpdate, mediaRequest.handleMaxFs);
     });
 
     delete this.clientRequests[requestId];
@@ -320,5 +427,14 @@ export class MediaRequestManager {
 
   public reset() {
     this.clientRequests = {};
+    this.numTotalSources = 0;
+    this.numLiveSources = 0;
+  }
+
+  public setNumCurrentSources(numTotalSources: number, numLiveSources: number) {
+    this.numTotalSources = numTotalSources;
+    this.numLiveSources = numLiveSources;
+
+    this.sendRequests();
   }
 }

package/src/multistream/receiveSlot.ts

@@ -3,7 +3,7 @@ import {
   MediaType,
   ReceiveSlot as WcmeReceiveSlot,
   ReceiveSlotEvents as WcmeReceiveSlotEvents,
-  SourceState,
+  StreamState,
 } from '@webex/internal-media-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
@@ -14,7 +14,7 @@ export const ReceiveSlotEvents = {
   MaxFsUpdate: 'maxFsUpdate',
 };
 
-export type {SourceState} from '@webex/internal-media-core';
+export type {StreamState} from '@webex/internal-media-core';
 export type CSI = number;
 export type MemberId = string;
 export type ReceiveSlotId = string;
@@ -40,7 +40,7 @@ export class ReceiveSlot extends EventsScope {
 
   #csi?: CSI;
 
-  #sourceState: SourceState;
+  #sourceState: StreamState;
 
   /**
    * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
@@ -119,7 +119,7 @@ export class ReceiveSlot extends EventsScope {
 
     this.mcReceiveSlot.on(
       WcmeReceiveSlotEvents.SourceUpdate,
-      (state: SourceState, csi?: number) => {
+      (state: StreamState, csi?: number) => {
         LoggerProxy.logger.log(
           `ReceiveSlot#setupEventListeners --> got source update on receive slot ${this.id}, mediaType=${this.mediaType}, csi=${csi}, state=${state}`
         );

package/src/multistream/receiveSlotManager.ts

@@ -59,7 +59,7 @@ export class ReceiveSlotManager {
     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;
     }
@@ -70,7 +70,7 @@ export class ReceiveSlotManager {
     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`
       );
     }
   }

package/src/multistream/remoteMedia.ts

@@ -1,5 +1,5 @@
 /* eslint-disable valid-jsdoc */
-import {MediaType, SourceState} from '@webex/internal-media-core';
+import {MediaType, StreamState} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsScope from '../common/events/events-scope';
 
@@ -233,7 +233,7 @@ export class RemoteMedia extends EventsScope {
   /**
    * Getter for source state
    */
-  public get sourceState(): SourceState {
+  public get sourceState(): StreamState {
     return this.receiveSlot?.sourceState;
   }
 

package/src/multistream/remoteMediaGroup.ts

@@ -1,6 +1,7 @@
 /* eslint-disable valid-jsdoc */
 /* eslint-disable require-jsdoc */
 /* eslint-disable import/prefer-default-export */
+import {forEach} from 'lodash';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {getMaxFs, RemoteMedia, RemoteVideoResolution} from './remoteMedia';
@@ -66,6 +67,53 @@ export class RemoteMediaGroup {
     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.
@@ -151,6 +199,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);
 

package/src/multistream/remoteMediaManager.ts

@@ -96,6 +96,7 @@ const OnePlusFiveLayout: VideoLayout = {
 };
 
 // A layout with 2 big panes for 2 main active speakers and a strip of 6 small panes for other active speakers:
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const TwoMainPlusSixSmallLayout: VideoLayout = {
   activeSpeakerVideoPaneGroups: [
     {
@@ -490,6 +491,38 @@ export class RemoteMediaManager extends EventsScope {
     return this.currentLayoutId;
   }
 
+  /**
+   * sets the preferLiveVideo
+   */
+  public setPreferLiveVideo(preferLiveVideo: boolean) {
+    LoggerProxy.logger.log(
+      `RemoteMediaManager#setPreferLiveVideo --> setPreferLiveVideo is called to set preferLiveVideo to ${preferLiveVideo}`
+    );
+    this.config.video.preferLiveVideo = preferLiveVideo;
+    Object.values(this.media.video.activeSpeakerGroups).forEach((activeSpeakerGroup) => {
+      activeSpeakerGroup.setPreferLiveVideo(preferLiveVideo, false);
+    });
+    this.mediaRequestManagers.video.commit();
+  }
+
+  /**
+   * Sets CSIs for multiple RemoteMedia instances belonging to 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
+   */
+  public setActiveSpeakerCsis(remoteMediaCsis: {remoteMedia: RemoteMedia; csi?: number}[]) {
+    Object.values(this.media.video.activeSpeakerGroups).forEach((remoteMediaGroup) => {
+      const groupRemoteMediaCsis = remoteMediaCsis.filter(({remoteMedia}) =>
+        remoteMediaGroup.includes(remoteMedia)
+      );
+      if (groupRemoteMediaCsis.length > 0) {
+        remoteMediaGroup.setActiveSpeakerCsis(groupRemoteMediaCsis, false);
+      }
+    });
+    this.mediaRequestManagers.video.commit();
+  }
+
   /**
    * Creates the audio slots
    */