@webex/plugin-meetings 3.12.0-next.2 → 3.12.0-next.4

package/src/multistream/sendSlotManager.ts

@@ -5,7 +5,11 @@ import {
   MultistreamRoapMediaConnection,
   NamedMediaGroup,
   StreamState,
+  MediaCodecMimeType,
+  CodecParameters,
 } from '@webex/internal-media-core';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 /**
  * This class is used to manage the sendSlots for the given media types.
@@ -206,6 +210,8 @@ export default class SendSlotManager {
   }
 
   /**
+   * @deprecated Use {@link setCustomCodecParameters} instead, which requires specifying the codec MIME type.
+   *
    * This method is used to set the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Object} codecParameters
@@ -226,12 +232,19 @@ export default class SendSlotManager {
 
     await slot.setCodecParameters(codecParameters);
 
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->setCodecParameters#Set codec parameters for ${mediaType} to ${codecParameters}`
+    this.LoggerProxy.logger.warn(
+      'SendSlotsManager->setCodecParameters --> [DEPRECATION WARNING]: setCodecParameters has been deprecated, use setCustomCodecParameters instead'
     );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_SET_CODEC_PARAMETERS_USED, {
+      mediaType,
+      codecParameters,
+    });
   }
 
   /**
+   * @deprecated Use {@link markCustomCodecParametersForDeletion} instead, which requires specifying the codec MIME type.
+   *
    * This method is used to delete the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Array<String>} parameters Array of keys of the codec parameters to be deleted
@@ -246,8 +259,89 @@ export default class SendSlotManager {
 
     await slot.deleteCodecParameters(parameters);
 
+    this.LoggerProxy.logger.warn(
+      'SendSlotsManager->deleteCodecParameters --> [DEPRECATION WARNING]: deleteCodecParameters has been deprecated, use markCustomCodecParametersForDeletion instead'
+    );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_DELETE_CODEC_PARAMETERS_USED, {
+      mediaType,
+      parameters,
+    });
+  }
+
+  /**
+   * Sets custom codec parameters for the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+   * Delegates to WCME's setCustomCodecParameters API.
+   * @param {MediaType} mediaType MediaType of the sendSlot
+   * @param {MediaCodecMimeType} codecMimeType The codec MIME type to apply parameters to (e.g. OPUS, H264, AV1)
+   * @param {CodecParameters} parameters Key-value pairs of codec parameters to set
+   * @returns {Promise<void>}
+   */
+  public async setCustomCodecParameters(
+    mediaType: MediaType,
+    codecMimeType: MediaCodecMimeType,
+    parameters: CodecParameters
+  ): Promise<void> {
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    try {
+      await slot.setCustomCodecParameters(codecMimeType, parameters);
+
+      this.LoggerProxy.logger.info(
+        `SendSlotsManager->setCustomCodecParameters#Set custom codec parameters for ${mediaType} (codec: ${codecMimeType}) to ${JSON.stringify(
+          parameters
+        )}`
+      );
+    } catch (error) {
+      this.LoggerProxy.logger.error(
+        `SendSlotsManager->setCustomCodecParameters#Failed to set custom codec parameters for ${mediaType} (codec: ${codecMimeType}): ${error}`
+      );
+      throw error;
+    } finally {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED, {
+        mediaType,
+        codecMimeType,
+        parameters,
+      });
+    }
+  }
+
+  /**
+   * Marks custom codec parameters for deletion on the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+   * Delegates to WCME's markCustomCodecParametersForDeletion API.
+   * @param {MediaType} mediaType MediaType of the sendSlot
+   * @param {MediaCodecMimeType} codecMimeType The codec MIME type whose parameters should be deleted (e.g. OPUS, H264, AV1)
+   * @param {string[]} parameters Array of parameter keys to delete
+   * @returns {Promise<void>}
+   */
+  public async markCustomCodecParametersForDeletion(
+    mediaType: MediaType,
+    codecMimeType: MediaCodecMimeType,
+    parameters: string[]
+  ): Promise<void> {
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    await slot.markCustomCodecParametersForDeletion(codecMimeType, parameters);
+
     this.LoggerProxy.logger.info(
-      `SendSlotsManager->deleteCodecParameters#Deleted the following codec parameters -> ${parameters} for ${mediaType}`
+      `SendSlotsManager->markCustomCodecParametersForDeletion#Marked codec parameters for deletion -> ${parameters} for ${mediaType} (codec: ${codecMimeType})`
+    );
+
+    Metrics.sendBehavioralMetric(
+      BEHAVIORAL_METRICS.MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED,
+      {
+        mediaType,
+        codecMimeType,
+        parameters,
+      }
     );
   }
 

package/test/unit/spec/meeting/index.js

@@ -38,6 +38,7 @@ import {
 import {
   ConnectionState,
   MediaConnectionEventNames,
+  MediaCodecMimeType,
   StatsAnalyzerEventNames,
   StatsMonitorEventNames,
   Errors,
@@ -9214,8 +9215,8 @@ describe('plugin-meetings', () => {
         const fakeMultistreamRoapMediaConnection = {
           createSendSlot: () => {
             return {
-              setCodecParameters: sinon.stub().resolves(),
-              deleteCodecParameters: sinon.stub().resolves(),
+              setCustomCodecParameters: sinon.stub().resolves(),
+              markCustomCodecParametersForDeletion: sinon.stub().resolves(),
             };
           },
         };
@@ -9238,27 +9239,29 @@ describe('plugin-meetings', () => {
         }
       );
 
-      it('should set the codec parameters when shouldEnableMusicMode is true', async () => {
+      it('should set custom codec parameters when shouldEnableMusicMode is true', async () => {
         await meeting.enableMusicMode(true);
         assert.calledOnceWithExactly(
-          meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCodecParameters,
+          meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCustomCodecParameters,
+          MediaCodecMimeType.OPUS,
           {
             maxaveragebitrate: '64000',
             maxplaybackrate: '48000',
           }
         );
         assert.notCalled(
-          meeting.sendSlotManager.getSlot(MediaType.AudioMain).deleteCodecParameters
+          meeting.sendSlotManager.getSlot(MediaType.AudioMain).markCustomCodecParametersForDeletion
         );
       });
 
-      it('should set the codec parameters when shouldEnableMusicMode is false', async () => {
+      it('should mark custom codec parameters for deletion when shouldEnableMusicMode is false', async () => {
         await meeting.enableMusicMode(false);
         assert.calledOnceWithExactly(
-          meeting.sendSlotManager.getSlot(MediaType.AudioMain).deleteCodecParameters,
+          meeting.sendSlotManager.getSlot(MediaType.AudioMain).markCustomCodecParametersForDeletion,
+          MediaCodecMimeType.OPUS,
           ['maxaveragebitrate', 'maxplaybackrate']
         );
-        assert.notCalled(meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCodecParameters);
+        assert.notCalled(meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCustomCodecParameters);
       });
     });
 

package/test/unit/spec/multistream/sendSlotManager.ts

@@ -1,19 +1,28 @@
 import 'jsdom-global/register';
 import SendSlotManager from '@webex/plugin-meetings/src/multistream/sendSlotManager';
-import { LocalStream, MediaType, MultistreamRoapMediaConnection } from "@webex/internal-media-core";
-import {expect} from '@webex/test-helper-chai';
+import { LocalStream, MediaType, MultistreamRoapMediaConnection, MediaCodecMimeType } from "@webex/internal-media-core";
+import {assert, expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
 describe('SendSlotsManager', () => {
     let sendSlotsManager: SendSlotManager;
     const LoggerProxy = {
         logger: {
             info: sinon.stub(),
+            warn: sinon.stub(),
+            error: sinon.stub(),
         },
     };
 
     beforeEach(() => {
         sendSlotsManager = new SendSlotManager(LoggerProxy);
+        sinon.stub(Metrics, 'sendBehavioralMetric');
+    });
+
+    afterEach(() => {
+        sinon.restore();
     });
 
     describe('createSlot', () => {
@@ -29,13 +38,13 @@ describe('SendSlotsManager', () => {
         it('should create a slot for the given mediaType', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            expect(mediaConnection.createSendSlot.calledWith(mediaType, true));
+            assert.calledWith(mediaConnection.createSendSlot, mediaType, true);
         });
 
         it('should create a slot for the given mediaType & active state', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType, false);
 
-            expect(mediaConnection.createSendSlot.calledWith(mediaType, false));
+            assert.calledWith(mediaConnection.createSendSlot, mediaType, false);
         });
 
         it('should throw an error if a slot for the given mediaType already exists', () => {
@@ -86,14 +95,12 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.publishStream(mediaType, stream);
 
-            expect(slot.publishStream.calledWith(stream));
+            assert.calledWith(slot.publishStream, stream);
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
-            sendSlotsManager.publishStream(mediaType, stream).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.publishStream(mediaType, stream))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });
 
@@ -116,14 +123,12 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.unpublishStream(mediaType);
 
-            expect(slot.unpublishStream.called);
+            assert.called(slot.unpublishStream);
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist',(done) => {
-            sendSlotsManager.unpublishStream(mediaType).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.unpublishStream(mediaType))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });
 
@@ -147,7 +152,7 @@ describe('SendSlotsManager', () => {
 
       await sendSlotsManager.setNamedMediaGroups(mediaType, groups);
 
-      expect(slot.setNamedMediaGroups.calledWith(groups));
+      assert.calledWith(slot.setNamedMediaGroups, groups);
     });
 
     it('should throw an error if the given mediaType is not audio', () => {
@@ -169,16 +174,16 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should set the active state of the sendSlot for the given mediaType', async () => {
+        it('should set the active state of the sendSlot for the given mediaType', () => {
             const slot = {
-                setActive: sinon.stub().resolves(),
+                active: false,
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            await sendSlotsManager.setActive(mediaType,true);
+            sendSlotsManager.setActive(mediaType, true);
 
-            expect(slot.setActive.called);
+            expect(slot.active).to.be.true;
         });
 
         it('should throw an error if a slot for the given mediaType does not exist', () => {
@@ -197,7 +202,7 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should set the codec parameters of the sendSlot for the given mediaType', async () => {
+        it('should delegate to slot.setCodecParameters, log deprecation warning and send deprecation metric', async () => {
             const slot = {
                 setCodecParameters: sinon.stub().resolves(),
             };
@@ -206,14 +211,17 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.setCodecParameters(mediaType, codecParameters);
 
-            expect(slot.setCodecParameters.calledWith(codecParameters));
+            assert.calledWith(slot.setCodecParameters, codecParameters);
+            assert.called(LoggerProxy.logger.warn);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.DEPRECATED_SET_CODEC_PARAMETERS_USED,
+                { mediaType, codecParameters }
+            );
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
-            sendSlotsManager.setCodecParameters(mediaType, codecParameters).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.setCodecParameters(mediaType, codecParameters))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });
 
@@ -227,23 +235,114 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should delete the codec parameters of the sendSlot for the given mediaType', async () => {
+        it('should delegate to slot.deleteCodecParameters, log deprecation warning and send deprecation metric', async () => {
             const slot = {
                 deleteCodecParameters: sinon.stub().resolves(),
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            await sendSlotsManager.deleteCodecParameters(mediaType,[]);
+            await sendSlotsManager.deleteCodecParameters(mediaType, []);
+
+            assert.calledWith(slot.deleteCodecParameters, []);
+            assert.called(LoggerProxy.logger.warn);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.DEPRECATED_DELETE_CODEC_PARAMETERS_USED,
+                { mediaType, parameters: [] }
+            );
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.deleteCodecParameters(mediaType, []))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        });
+    });
+
+    describe('setCustomCodecParameters', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+        const codecMimeType = MediaCodecMimeType.OPUS;
+        const parameters = { maxaveragebitrate: '64000' };
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should set custom codec parameters on the sendSlot for the given mediaType and codec, log info and send metric', async () => {
+            const slot = {
+                setCustomCodecParameters: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+            await sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters);
+
+            assert.calledWith(slot.setCustomCodecParameters, codecMimeType, parameters);
+            assert.called(LoggerProxy.logger.info);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED,
+                { mediaType, codecMimeType, parameters }
+            );
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        });
+
+        it('should throw and log error when setCustomCodecParameters fails', async () => {
+            const error = new Error('codec parameter failure');
+            const slot = {
+                setCustomCodecParameters: sinon.stub().rejects(error),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+            await expect(sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters))
+                .to.be.rejectedWith('codec parameter failure');
+
+            assert.called(LoggerProxy.logger.error);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED,
+                { mediaType, codecMimeType, parameters }
+            );
+        });
+    });
+
+    describe('markCustomCodecParametersForDeletion', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+        const codecMimeType = MediaCodecMimeType.OPUS;
+        const parameters = ['maxaveragebitrate', 'maxplaybackrate'];
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should mark custom codec parameters for deletion on the sendSlot for the given mediaType and codec, log info and send metric', async () => {
+            const slot = {
+                markCustomCodecParametersForDeletion: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+            await sendSlotsManager.markCustomCodecParametersForDeletion(mediaType, codecMimeType, parameters);
 
-            expect(slot.deleteCodecParameters.called);
+            assert.calledWith(slot.markCustomCodecParametersForDeletion, codecMimeType, parameters);
+            assert.called(LoggerProxy.logger.info);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED,
+                { mediaType, codecMimeType, parameters }
+            );
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
-            sendSlotsManager.deleteCodecParameters(mediaType,[]).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.markCustomCodecParametersForDeletion(mediaType, codecMimeType, parameters))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });