@webex/plugin-meetings 3.0.0-beta.9 → 3.0.0-beta.91

package/src/metrics/index.ts

@@ -8,31 +8,21 @@ import uuid from 'uuid';
 import window from 'global/window';
 import anonymize from 'ip-anonymize';
 
+import {getOSNameInternal} from '@webex/internal-plugin-metrics';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {MEETING_ERRORS} from '../constants';
 import BrowserDetection from '../common/browser-detection';
 
 import {
-  error, eventType, errorCodes as ERROR_CODE, OS_NAME, UNKNOWN, CLIENT_NAME,
-  mediaType
+  error,
+  eventType,
+  errorCodes as ERROR_CODE,
+  UNKNOWN,
+  CLIENT_NAME,
+  mediaType,
 } from './config';
 
-const OSMap = {
-  // @ts-ignore
-  'Chrome OS': OS_NAME.chrome,
-  macOS: OS_NAME.MAC,
-  Windows: OS_NAME.WINDOWS,
-  iOS: OS_NAME.IOS,
-  Android: OS_NAME.ANDROID,
-  Linux: OS_NAME.LINUX
-};
-
-const {
-  getOSName,
-  getOSVersion,
-  getBrowserName,
-  getBrowserVersion
-} = BrowserDetection();
+const {getOSName, getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
 
 // Apply a CIDR /28 format to the IPV4 and /96 to the IPV6 addresses
 // For reference : https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
@@ -85,33 +75,33 @@ class Metrics {
   webex: any;
 
   /**
-     * Create Metrics Object
-     * @constructor
-     * @public
-     * @memberof Meetings
-     */
+   * Create Metrics Object
+   * @constructor
+   * @public
+   * @memberof Meetings
+   */
   constructor() {
     if (!Metrics.instance) {
-    /**
-     * @instance
-     * @type {Array}
-     * @private
-     * @memberof Metrics
-     */
+      /**
+       * @instance
+       * @type {Array}
+       * @private
+       * @memberof Metrics
+       */
       this._events = [];
       /**
-     * @instance
-     * @type {MeetingCollection}
-     * @private
-     * @memberof Metrics
-     */
+       * @instance
+       * @type {MeetingCollection}
+       * @private
+       * @memberof Metrics
+       */
       this.meetingCollection = null;
       /**
-     * @instance
-     * @type {MeetingCollection}
-     * @private
-     * @memberof Metrics
-     */
+       * @instance
+       * @type {MeetingCollection}
+       * @private
+       * @memberof Metrics
+       */
       this.keys = Object.values(eventType);
       /**
        * @instance
@@ -122,6 +112,7 @@ class Metrics {
       Metrics.instance = this;
     }
 
+    // eslint-disable-next-line no-constructor-return
     return Metrics.instance;
   }
 
@@ -147,12 +138,14 @@ class Metrics {
    * @param {object} options.event
    * @returns {object} null
    */
-  postEvent(options: { meeting?: any; meetingId?: string; data?: object; event?: any } | any) {
+  postEvent(options: {meeting?: any; meetingId?: string; data?: object; event?: any} | any) {
     const {meetingId, data = {}, event} = options;
     let {meeting} = options;
 
     if (this.keys.indexOf(event) === -1) {
-      LoggerProxy.logger.error(`Metrics:index#postEvent --> Event ${event} doesn't exist in dictionary`);
+      LoggerProxy.logger.error(
+        `Metrics:index#postEvent --> Event ${event} doesn't exist in dictionary`
+      );
     }
 
     if (!meeting && meetingId) {
@@ -169,25 +162,25 @@ class Metrics {
       if (event === eventType.MEDIA_QUALITY) {
         data.event = event;
         meeting.sendMediaQualityAnalyzerMetrics(data);
-      }
-      else {
+      } else {
         meeting.callEvents.push(event);
         data.event = event;
         meeting.sendCallAnalyzerMetrics(data);
       }
-    }
-
-    else {
-      LoggerProxy.logger.info(`Metrics:index#postEvent --> Event received for meetingId:${meetingId}, but meeting not found in collection.`);
+    } else {
+      LoggerProxy.logger.info(
+        `Metrics:index#postEvent --> Event received for meetingId:${meetingId}, but meeting not found in collection.`
+      );
     }
   }
 
   /**
    *  Docs for Call analyzer metrics
-  *   https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki
-  *   https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml
- */
+   *   https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki
+   *   https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml
+   */
 
+  // eslint-disable-next-line @typescript-eslint/no-shadow
   initPayload(eventType, identifiers, options) {
     const payload: any = {
       eventId: uuid.v4(),
@@ -202,21 +195,21 @@ class Metrics {
           localNetworkPrefix: anonymizeIPAddress(this.webex.meetings.geoHintInfo?.clientAddress),
           osVersion: getOSVersion() || 'unknown',
           subClientType: options.subClientType,
-          os: this.getOsName(),
+          os: getOSNameInternal(),
           browser: getBrowserName(),
-          browserVersion: getBrowserVersion()
-        }
+          browserVersion: getBrowserVersion(),
+        },
       },
       originTime: {
-        triggered: new Date().toISOString()
+        triggered: new Date().toISOString(),
       },
       senderCountryCode: this.webex.meetings.geoHintInfo?.countryCode,
       event: {
         name: eventType,
         canProceed: true,
         identifiers,
-        eventData: {webClientDomain: window.location.hostname}
-      }
+        eventData: {webClientDomain: window.location.hostname},
+      },
     };
 
     // TODO: more options should be checked and some of them should be mandatory in certain conditions
@@ -248,22 +241,16 @@ class Metrics {
       if (options.isRoapCallEnabled) {
         payload.event.isRoapCallEnabled = options.isRoapCallEnabled;
       }
+      ['breakoutMoveId', 'breakoutSessionId', 'breakoutGroupId'].forEach((item) => {
+        if (options[item]) {
+          payload.event.identifiers[item] = options[item];
+        }
+      });
     }
 
     return payload;
   }
 
-  /**
-   * returns metrics friendly OS versions
-   * @param {String} osName Os name
-   * @returns {String}
-   * @private
-   * @memberof Metrics
-   */
-  private getOsName() {
-    return OSMap[getOSName()] ?? OS_NAME.OTHERS;
-  }
-
   /**
    * get the payload specific for a media quality event through call analyzer
    * @param {String} eventType the event name
@@ -279,16 +266,19 @@ class Metrics {
    * @memberof Metrics
    */
   public initMediaPayload(
+    // eslint-disable-next-line @typescript-eslint/no-shadow
     eventType: string,
     identifiers: {
       correlationId: string;
       locusUrl: string;
       locusId: string;
     },
-    options: {
-      intervalData: object;
-      clientType: string;
-    } | any = {}
+    options:
+      | {
+          intervalData: object;
+          clientType: string;
+        }
+      | any = {}
   ) {
     const {audioSetupDelay, videoSetupDelay, joinTimes} = options;
 
@@ -305,15 +295,15 @@ class Metrics {
           clientType: options.clientType, // TODO: Only clientType: 'TEAMS_CLIENT' is whitelisted
           clientVersion: `${CLIENT_NAME}/${this.webex.version}`,
           localNetworkPrefix: anonymizeIPAddress(this.webex.meetings.geoHintInfo?.clientAddress),
-          os: this.getOsName(),
+          os: getOSNameInternal(),
           osVersion: getOSVersion() || UNKNOWN,
           subClientType: options.subClientType,
           browser: getBrowserName(),
-          browserVersion: getBrowserVersion()
-        }
+          browserVersion: getBrowserVersion(),
+        },
       },
       originTime: {
-        triggered: new Date().toISOString()
+        triggered: new Date().toISOString(),
       },
       senderCountryCode: this.webex.meetings.geoHintInfo?.countryCode,
       event: {
@@ -323,16 +313,16 @@ class Metrics {
         intervals: [options.intervalData],
         joinTimes,
         eventData: {
-          webClientDomain: window.location.hostname
+          webClientDomain: window.location.hostname,
         },
         sourceMetadata: {
           applicationSoftwareType: CLIENT_NAME,
           applicationSoftwareVersion: this.webex.version,
           mediaEngineSoftwareType: getBrowserName() || 'browser',
           mediaEngineSoftwareVersion: getOSVersion() || UNKNOWN,
-          startTime: new Date().toISOString()
-        }
-      }
+          startTime: new Date().toISOString(),
+        },
+      },
     };
 
     return payload;
@@ -353,8 +343,7 @@ class Metrics {
 
     if (err && err.statusCode && err.statusCode >= 500) {
       errorCode = 1003;
-    }
-    else if (err && err.body && err.body.errorCode) {
+    } else if (err && err.body && err.body.errorCode) {
       // locus error codes: https://sqbu-github.cisco.com/WebExSquared/locus/blob/master/server/src/main/resources/locus-error-codes.properties
       switch (ERROR_CODE[err.body.errorCode]) {
         case MEETING_ERRORS.FREE_USER_MAX_PARTICIPANTS_EXCEEDED:
@@ -453,17 +442,13 @@ class Metrics {
         default:
           errorCode = 4008;
       }
-    }
-    else {
+    } else {
       errorCode = 4008;
     }
 
-    return this.generateErrorPayload(
-      errorCode, showToUser, error.name.LOCUS_RESPONSE, err
-    );
+    return this.generateErrorPayload(errorCode, showToUser, error.name.LOCUS_RESPONSE, err);
   }
 
-
   generateErrorPayload(errorCode, shownToUser, name, err) {
     if (error.errors[errorCode]) {
       const errorPayload: any = {
@@ -472,11 +457,11 @@ class Metrics {
         errorDescription: error.errors[errorCode][0],
         errorCode,
         fatal: !includes(error.notFatalErrorList, errorCode),
-        name: name || error.name.OTHER
+        name: name || error.name.OTHER,
       };
 
       if (err && err.body) {
-        errorPayload.errorData = err.body;
+        errorPayload.errorData = {error: err.body};
       }
 
       if (err && err.statusCode) {
@@ -499,8 +484,14 @@ class Metrics {
     let browserInfo;
     const clientInfo = util.format('client=%s', `${this.webex.meetings?.metrics?.clientName}`);
 
-    if (['chrome', 'firefox', 'msie', 'msedge', 'safari'].indexOf(getBrowserName().toLowerCase()) !== -1) {
-      browserInfo = util.format('browser=%s', `${getBrowserName().toLowerCase()}/${getBrowserVersion().split('.')[0]}`);
+    if (
+      ['chrome', 'firefox', 'msie', 'msedge', 'safari'].indexOf(getBrowserName().toLowerCase()) !==
+      -1
+    ) {
+      browserInfo = util.format(
+        'browser=%s',
+        `${getBrowserName().toLowerCase()}/${getBrowserVersion().split('.')[0]}`
+      );
     }
     const osInfo = util.format('os=%s', `${getOSName()}/${getOSVersion().split('.')[0]}`);
 
@@ -508,12 +499,18 @@ class Metrics {
       userAgentOption = `(${browserInfo}`;
     }
     if (osInfo) {
-      userAgentOption = userAgentOption ? `${userAgentOption}; ${clientInfo}; ${osInfo}` : `${clientInfo}; (${osInfo}`;
+      userAgentOption = userAgentOption
+        ? `${userAgentOption}; ${clientInfo}; ${osInfo}`
+        : `${clientInfo}; (${osInfo}`;
     }
     if (userAgentOption) {
       userAgentOption += ')';
 
-      return util.format('webex-js-sdk/%s %s', `${process.env.NODE_ENV}-${this.webex.version}`, userAgentOption);
+      return util.format(
+        'webex-js-sdk/%s %s',
+        `${process.env.NODE_ENV}-${this.webex.version}`,
+        userAgentOption
+      );
     }
 
     return util.format('webex-js-sdk/%s', `${process.env.NODE_ENV}-${this.webex.version}`);
@@ -538,7 +535,7 @@ class Metrics {
     this.webex.internal.metrics.submitClientMetrics(metricName, {
       type: this.webex.config.metrics.type,
       fields: metricFields,
-      tags: metricTags
+      tags: metricTags,
     });
   }
 }

package/src/multistream/mediaRequestManager.ts

@@ -1,9 +1,20 @@
 /* eslint-disable require-jsdoc */
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {
+  MediaRequest as WcmeMediaRequest,
+  Policy,
+  ActiveSpeakerInfo,
+  ReceiverSelectedInfo,
+  CodecInfo as WcmeCodecInfo,
+  H264Codec,
+  getRecommendedMaxBitrateForFrameSize,
+  RecommendedOpusBitrates,
+} from '@webex/internal-media-core';
+import {cloneDeep, debounce, isEmpty} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 
-import {ReceiveSlot, ReceiveSlotId} from './receiveSlot';
+import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
+import {getMaxFs} from './remoteMedia';
 
 export interface ActiveSpeakerPolicyInfo {
   policy: 'active-speaker';
@@ -35,6 +46,7 @@ export interface MediaRequest {
   policyInfo: PolicyInfo;
   receiveSlots: Array<ReceiveSlot>;
   codecInfo?: CodecInfo;
+  preferredMaxFs?: number;
 }
 
 export type MediaRequestId = string;
@@ -47,79 +59,206 @@ const CODEC_DEFAULTS = {
   },
 };
 
-type SendMediaRequestsCallback = (mediaRequests: MC.MediaRequest[]) => void;
+const DEBOUNCED_SOURCE_UPDATE_TIME = 1000;
 
+type DegradationPreferences = {
+  maxMacroblocksLimit: number;
+};
+
+type SendMediaRequestsCallback = (mediaRequests: WcmeMediaRequest[]) => void;
+type Kind = 'audio' | 'video';
+
+type Options = {
+  degradationPreferences: DegradationPreferences;
+  kind: Kind;
+};
 export class MediaRequestManager {
   private sendMediaRequestsCallback: SendMediaRequestsCallback;
 
-  private counter;
+  private kind: Kind;
+
+  private counter: number;
 
   private clientRequests: {[key: MediaRequestId]: MediaRequest};
 
-  private slotsActiveInLastMediaRequest: {[key: ReceiveSlotId]: ReceiveSlot};
+  private degradationPreferences: DegradationPreferences;
 
-  constructor(sendMediaRequestsCallback: SendMediaRequestsCallback) {
+  private sourceUpdateListener: () => void;
+
+  private debouncedSourceUpdateListener: () => void;
+
+  private previousWCMEMediaRequests: Array<WcmeMediaRequest> = [];
+
+  constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options) {
     this.sendMediaRequestsCallback = sendMediaRequestsCallback;
     this.counter = 0;
     this.clientRequests = {};
-    this.slotsActiveInLastMediaRequest = {};
+    this.degradationPreferences = options.degradationPreferences;
+    this.kind = options.kind;
+    this.sourceUpdateListener = this.commit.bind(this);
+    this.debouncedSourceUpdateListener = debounce(
+      this.sourceUpdateListener,
+      DEBOUNCED_SOURCE_UPDATE_TIME
+    );
   }
 
-  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;
-      })
-    );
+  public setDegradationPreferences(degradationPreferences: DegradationPreferences) {
+    this.degradationPreferences = degradationPreferences;
+    this.sendRequests(); // re-send requests after preferences are set
+  }
 
-    // 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}`
+  private getDegradedClientRequests() {
+    const clientRequests = cloneDeep(this.clientRequests);
+    const maxFsLimits = [
+      getMaxFs('best'),
+      getMaxFs('large'),
+      getMaxFs('medium'),
+      getMaxFs('small'),
+      getMaxFs('very small'),
+      getMaxFs('thumbnail'),
+    ];
+
+    // 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]) => {
+        if (mr.codecInfo) {
+          mr.codecInfo.maxFs = Math.min(
+            mr.preferredMaxFs || CODEC_DEFAULTS.h264.maxFs,
+            mr.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs,
+            maxFsLimits[i]
+          );
+          // we only consider sources with "live" state
+          const slotsWithLiveSource = this.clientRequests[id].receiveSlots.filter(
+            (rs) => rs.sourceState === 'live'
+          );
+          totalMacroblocksRequested += mr.codecInfo.maxFs * slotsWithLiveSource.length;
+        }
+      });
+      if (totalMacroblocksRequested <= this.degradationPreferences.maxMacroblocksLimit) {
+        if (i !== 0) {
+          LoggerProxy.logger.warn(
+            `multistream:mediaRequestManager --> too many streams with high max-fs, frame size will be limited to ${maxFsLimits[i]}`
+          );
+        }
+        break;
+      } else if (i === maxFsLimits.length - 1) {
+        LoggerProxy.logger.warn(
+          `multistream:mediaRequestManager --> even with frame size limited to ${maxFsLimits[i]} you are still requesting too many streams, consider reducing the number of requests`
         );
-        slot.resetSourceState();
       }
     }
 
-    this.slotsActiveInLastMediaRequest = activeSlots;
+    return clientRequests;
+  }
+
+  /**
+   * Returns true if two media requests are the same, false otherwise.
+   *
+   * @param {WcmeMediaRequest} mediaRequestA - Media request A for comparison.
+   * @param {WcmeMediaRequest} mediaRequestB - Media request B for comparison.
+   * @returns {boolean} - Whether they are equal.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  public isEqual(mediaRequestA: WcmeMediaRequest, mediaRequestB: WcmeMediaRequest) {
+    return (
+      JSON.stringify(mediaRequestA._toJmpScrRequest()) ===
+      JSON.stringify(mediaRequestB._toJmpScrRequest())
+    );
+  }
+
+  /**
+   * Compares new media requests to previous ones and determines
+   * if they are the same.
+   *
+   * @param {WcmeMediaRequest[]} newRequests - Array with new requests.
+   * @returns {boolean} - True if they are equal, false otherwise.
+   */
+  private checkIsNewRequestsEqualToPrev(newRequests: WcmeMediaRequest[]) {
+    return (
+      !isEmpty(this.previousWCMEMediaRequests) &&
+      this.previousWCMEMediaRequests.length === newRequests.length &&
+      this.previousWCMEMediaRequests.every((req, idx) => this.isEqual(req, newRequests[idx]))
+    );
+  }
+
+  /**
+   * Returns the maxPayloadBitsPerSecond per Stream
+   *
+   * If MediaRequestManager kind is "audio", a constant bitrate will be returned.
+   * If MediaRequestManager kind is "video", the bitrate will be calculated based
+   * on maxFs (default h264 maxFs as fallback if maxFs is not defined)
+   *
+   * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+   * @returns {number} maxPayloadBitsPerSecond
+   */
+  private getMaxPayloadBitsPerSecond(mediaRequest: MediaRequest): number {
+    if (this.kind === 'audio') {
+      // return mono_music bitrate default if the kind of mediarequest manager is audio:
+      return RecommendedOpusBitrates.FB_MONO_MUSIC;
+    }
+
+    return getRecommendedMaxBitrateForFrameSize(
+      mediaRequest.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs
+    );
+  }
+
+  /**
+   * Returns the max Macro Blocks per second (maxMbps) per H264 Stream
+   *
+   * The maxMbps will be calculated based on maxFs and maxFps
+   * (default h264 maxFps as fallback if maxFps is not defined)
+   *
+   * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+   * @returns {number} maxMbps
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private getH264MaxMbps(mediaRequest: MediaRequest): number {
+    // fallback for maxFps (not needed for maxFs, since there is a fallback already in getDegradedClientRequests)
+    const maxFps = mediaRequest.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps;
+
+    // divided by 100 since maxFps is 3000 (for 30 frames per seconds)
+    return (mediaRequest.codecInfo.maxFs * maxFps) / 100;
+  }
+
+  /**
+   * Clears the previous media requests.
+   *
+   * @returns {void}
+   */
+  public clearPreviousRequests(): void {
+    this.previousWCMEMediaRequests = [];
   }
 
   private sendRequests() {
-    const wcmeMediaRequests: MC.MediaRequest[] = [];
+    const wcmeMediaRequests: WcmeMediaRequest[] = [];
 
-    // todo: check how many streams we're asking for and what resolution and introduce some limits (spark-377701)
-    const maxPayloadBitsPerSecond = 10 * 1000 * 1000;
+    const clientRequests = this.getDegradedClientRequests();
 
     // map all the client media requests to wcme media requests
-    Object.values(this.clientRequests).forEach((mr) => {
+    Object.values(clientRequests).forEach((mr) => {
       wcmeMediaRequests.push(
-        new MC.MediaRequest(
+        new WcmeMediaRequest(
           mr.policyInfo.policy === 'active-speaker'
-            ? MC.Policy.ActiveSpeaker
-            : MC.Policy.ReceiverSelected,
+            ? Policy.ActiveSpeaker
+            : Policy.ReceiverSelected,
           mr.policyInfo.policy === 'active-speaker'
-            ? new MC.ActiveSpeakerInfo(
+            ? new ActiveSpeakerInfo(
                 mr.policyInfo.priority,
                 mr.policyInfo.crossPriorityDuplication,
                 mr.policyInfo.crossPolicyDuplication,
                 mr.policyInfo.preferLiveVideo
               )
-            : new MC.ReceiverSelectedInfo(mr.policyInfo.csi),
+            : new ReceiverSelectedInfo(mr.policyInfo.csi),
           mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
-          maxPayloadBitsPerSecond,
+          this.getMaxPayloadBitsPerSecond(mr),
           mr.codecInfo && [
-            new MC.CodecInfo(
+            new WcmeCodecInfo(
               0x80,
-              new MC.H264Codec(
-                mr.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs,
+              new H264Codec(
+                mr.codecInfo.maxFs,
                 mr.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps,
-                mr.codecInfo.maxMbps || CODEC_DEFAULTS.h264.maxMbps,
+                this.getH264MaxMbps(mr),
                 mr.codecInfo.maxWidth,
                 mr.codecInfo.maxHeight
               )
@@ -129,9 +268,17 @@ export class MediaRequestManager {
       );
     });
 
-    this.sendMediaRequestsCallback(wcmeMediaRequests);
-
-    this.resetInactiveReceiveSlots();
+    //! 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;
+      LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
+    } else {
+      LoggerProxy.logger.info(
+        `multistream:sendRequests --> detected duplicate WCME requests, skipping them... `
+      );
+    }
   }
 
   public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {
@@ -140,6 +287,14 @@ export class MediaRequestManager {
 
     this.clientRequests[newId] = mediaRequest;
 
+    mediaRequest.receiveSlots.forEach((rs) => {
+      rs.on(ReceiveSlotEvents.SourceUpdate, this.sourceUpdateListener);
+      rs.on(ReceiveSlotEvents.MaxFsUpdate, ({maxFs}) => {
+        mediaRequest.preferredMaxFs = maxFs;
+        this.debouncedSourceUpdateListener();
+      });
+    });
+
     if (commit) {
       this.commit();
     }
@@ -148,6 +303,10 @@ export class MediaRequestManager {
   }
 
   public cancelRequest(requestId: MediaRequestId, commit = true) {
+    this.clientRequests[requestId]?.receiveSlots.forEach((rs) => {
+      rs.off(ReceiveSlotEvents.SourceUpdate, this.sourceUpdateListener);
+    });
+
     delete this.clientRequests[requestId];
 
     if (commit) {
@@ -161,6 +320,5 @@ export class MediaRequestManager {
 
   public reset() {
     this.clientRequests = {};
-    this.slotsActiveInLastMediaRequest = {};
   }
 }