@webex/plugin-meetings 3.0.0-beta.39 → 3.0.0-beta.391

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

@@ -15,6 +15,10 @@ import {cloneDeep} from 'lodash';
 import {MediaRequest} from '@webex/plugin-meetings/src/multistream/mediaRequestManager';
 import {CSI, ReceiveSlotId} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import testUtils from '../../../utils/testUtils';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
+import { expect } from 'chai';
+import { NamedMediaGroup } from "@webex/json-multistream";
 
 class FakeSlot extends EventEmitter {
   public mediaType: MediaType;
@@ -32,6 +36,10 @@ class FakeSlot extends EventEmitter {
     // Calling setMaxListeners() fixes the warning.
     this.setMaxListeners(50);
   }
+
+  public get logString() {
+    return this.id;
+  }
 }
 
 const DefaultTestConfiguration: Configuration = {
@@ -120,7 +128,23 @@ describe('RemoteMediaManager', () => {
   let fakeScreenShareAudioSlot;
   let fakeScreenShareVideoSlot;
 
+  const logger = {
+    log: sinon.fake(),
+    error: () => {},
+    warn: () => {},
+    trace: () => {},
+    debug: () => {},
+  };
+
+  afterEach(() => {
+    LoggerConfig.set({enable: false});
+    LoggerProxy.set();
+  });
+
   beforeEach(() => {
+    LoggerConfig.set({enable: true});
+    LoggerProxy.set(logger);
+
     fakeAudioSlot = new FakeSlot(MediaType.AudioMain, 'fake audio slot');
     fakeVideoSlot = new FakeSlot(MediaType.VideoMain, 'fake video slot');
     fakeScreenShareAudioSlot = new FakeSlot(
@@ -191,6 +215,7 @@ describe('RemoteMediaManager', () => {
     fakeMediaRequestManagers.video.commit.resetHistory();
     fakeMediaRequestManagers.screenShareVideo.commit.resetHistory();
     fakeMediaRequestManagers.screenShareAudio.commit.resetHistory();
+    logger.log.resetHistory();
   };
 
   describe('start', () => {
@@ -275,6 +300,204 @@ describe('RemoteMediaManager', () => {
       );
     });
 
+    it('creates a RemoteMediaGroup for named media group audio correctly', async () => {
+      let createdInterpretationAudioGroup: RemoteMediaGroup | null = null;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 20},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.InterpretationAudioCreated, (audio: RemoteMediaGroup) => {
+        createdInterpretationAudioGroup = audio;
+      });
+
+      remoteMediaManager.start();
+
+      await testUtils.flushPromises();
+
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+      assert.alwaysCalledWith(fakeReceiveSlotManager.allocateSlot, MediaType.AudioMain);
+
+      assert.isNotNull(createdInterpretationAudioGroup);
+      if (createdInterpretationAudioGroup) {
+        assert.strictEqual(createdInterpretationAudioGroup.getRemoteMedia().length, 1);
+        assert.isTrue(
+          createdInterpretationAudioGroup
+            .getRemoteMedia()
+            .every((remoteMedia) => remoteMedia.mediaType === MediaType.AudioMain)
+        );
+        assert.strictEqual(createdInterpretationAudioGroup.getRemoteMedia('pinned').length, 0);
+        assert.calledTwice(fakeMediaRequestManagers.audio.addRequest);
+        assert.calledWith(
+          fakeMediaRequestManagers.audio.addRequest,
+          sinon.match({
+            policyInfo: sinon.match({
+              policy: 'active-speaker',
+              priority: 255,
+              namedMediaGroups: sinon.match([{type: 1, value: 20}]),
+            }),
+            receiveSlots: Array(1).fill(fakeAudioSlot),
+            codecInfo: undefined,
+          }),
+          false,
+        );
+      }
+    });
+
+    it('creates new media request when call setReceiveNamedMediaGroup', async () => {
+      let createdInterpretationAudioGroup: RemoteMediaGroup | null = null;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.InterpretationAudioCreated, (audio: RemoteMediaGroup) => {
+        createdInterpretationAudioGroup = audio;
+        createdInterpretationAudioGroup.setNamedMediaGroup = sinon.stub();
+      });
+
+      await remoteMediaManager.start();
+
+      // requires 3 main audio slots and one interpretation audio slot
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+
+
+      resetHistory();
+
+
+      remoteMediaManager.setReceiveNamedMediaGroup(MediaType.AudioMain, 28);
+
+      // check that setNamedMediaGroup has been called
+      assert.calledOnce(createdInterpretationAudioGroup.setNamedMediaGroup);
+      assert.calledWith(
+        createdInterpretationAudioGroup.setNamedMediaGroup,
+        {type: 1, value: 28},
+        true,
+      );
+
+    });
+
+    it('ignore duplicated group when call setReceiveNamedMediaGroup', async () => {
+      let createdAudioGroup: RemoteMediaGroup | null = null;
+      let audioStopStub;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.AudioCreated, (audio: RemoteMediaGroup) => {
+        audioStopStub = sinon.stub(audio, 'stop');
+      });
+
+      await remoteMediaManager.start();
+
+      // we're using the default config that requires 3 main audio slots
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+
+
+      resetHistory();
+
+      remoteMediaManager.setReceiveNamedMediaGroup(MediaType.AudioMain, 24);
+
+      assert.notCalled(audioStopStub);
+      assert.callCount(fakeReceiveSlotManager.releaseSlot, 0);
+
+      await testUtils.flushPromises();
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 0);
+      assert.notCalled(fakeReceiveSlotManager.allocateSlot);
+
+    });
+
+
+    it('should throw error if set receive named media group which type is not audio', async () => {
+      let createdAudioGroup: RemoteMediaGroup | null = null;
+      let audioStopStub;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      // Assuming setReceiveNamedMediaGroup returns a promise
+      it('should throw error when media type is not audio-main', async () => {
+        try {
+          await remoteMediaManager.setReceiveNamedMediaGroup(MediaType.VideoMain, 0);
+          // If the promise resolves successfully, we should fail the test
+          throw new Error('Expected an error but none was thrown');
+        } catch (error) {
+          // Check if the error message matches the expected one
+          expect(error.message).to.equal('cannot set receive named media group which media type is not audio-main');
+        }
+      });
+    });
+
     it('pre-allocates receive slots based on the biggest layout', async () => {
       const config = cloneDeep(DefaultTestConfiguration);
 
@@ -639,6 +862,41 @@ describe('RemoteMediaManager', () => {
       remoteMediaManager.stop();
     });
   });
+
+  describe('setPreferLiveVideo', () => {
+
+    it('sets preferLiveVideo', async () => {
+      const config = cloneDeep(DefaultTestConfiguration);
+      let stubs = [];
+
+      config.video.initialLayoutId = 'OnePlusFive';
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        Object.values(layoutInfo.activeSpeakerVideoPanes).forEach((group) => stubs.push(sinon.stub(group, 'setPreferLiveVideo')));
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+      assert(stubs.length > 0);
+      await remoteMediaManager.setPreferLiveVideo(true);
+
+
+      stubs.forEach((stub) => {
+        assert.calledWith(stub, true, false)
+      });
+
+      expect(config.video.preferLiveVideo).to.equal(true);
+
+      assert.calledOnce(fakeMediaRequestManagers.video.commit);
+    });
+  });
+
   describe('setLayout', () => {
     it('rejects if called with invalid layoutId', async () => {
       await assert.isRejected(remoteMediaManager.setLayout('invalid value'));
@@ -671,6 +929,58 @@ describe('RemoteMediaManager', () => {
       assert.alwaysCalledWith(fakeReceiveSlotManager.allocateSlot, MediaType.VideoMain);
     });
 
+    it('logs layout changes - receiver selected', async () => {
+      const config = cloneDeep(DefaultTestConfiguration);
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      resetHistory();
+
+      await remoteMediaManager.setLayout('Stage');
+
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#setLayout --> new layout selected: Stage'
+      );
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#logMainVideoReceiveSlots --> MAIN VIDEO receive slots: unused=0, activeSpeaker=6, receiverSelected=4\ngroup: thumbnails\nfake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot\nreceiverSelected:\n stage-1: fake video slot\n stage-2: fake video slot\n stage-3: fake video slot\n stage-4: fake video slot\n'
+      );
+    });
+
+    it('logs layout changes - active speaker', async () => {
+      const config = cloneDeep(DefaultTestConfiguration);
+      config.video.initialLayoutId = 'OnePlusFive'
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      resetHistory();
+
+      await remoteMediaManager.setLayout('AllEqual');
+
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#setLayout --> new layout selected: AllEqual'
+      );
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#logMainVideoReceiveSlots --> MAIN VIDEO receive slots: unused=0, activeSpeaker=9, receiverSelected=0\ngroup: main\nfake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot\nreceiverSelected:\n'
+      );
+    });
+
+
     it('releases slots when switching to layout that requires less active speaker slots', async () => {
       // start with "AllEqual" layout that needs just 9 video slots
       const config = cloneDeep(DefaultTestConfiguration);
@@ -699,6 +1009,133 @@ describe('RemoteMediaManager', () => {
       });
     });
 
+    it('releases slots and reallocates slots when switching to layouts in correct order', async () => {
+
+      const config = cloneDeep(DefaultTestConfiguration);
+      let count = 0;
+
+      fakeReceiveSlotManager.allocateSlot = sinon.stub().callsFake((mediaType) => {
+        switch (mediaType) {
+          case MediaType.AudioMain:
+            return Promise.resolve(fakeAudioSlot);
+          case MediaType.VideoMain:
+            return Promise.resolve(new FakeSlot(MediaType.VideoMain, `fake video ${count++}`));
+          case MediaType.AudioSlides:
+            return Promise.resolve(fakeScreenShareAudioSlot);
+          case MediaType.VideoSlides:
+            return Promise.resolve(fakeScreenShareVideoSlot);
+        }
+        throw new Error(`invalid mediaType: ${mediaType}`);
+      })
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      resetHistory();
+
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 6",
+        "fake video 7",
+        "fake video 8",
+      ]);
+
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["main"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 6",
+        "fake video 7",
+        "fake video 8",
+      ])
+
+      // switch to "OnePlusFive" layout that requires 3 less video slots (6)
+      await remoteMediaManager.setLayout('OnePlusFive');
+
+      assert.deepEqual(remoteMediaManager.slots.video.unused, []);
+
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5"
+      ]);
+
+      // we're checking that the slots are in the same order as in the previous layout
+      // first one goes into main
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["mainBigOne"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+      ])
+      // and rest go in the pips
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["secondarySetOfSmallPanes"].slots.map((slot: any) => slot.id), [
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5"
+      ])
+
+      // verify that 3 main video slots were released
+      assert.callCount(fakeReceiveSlotManager.releaseSlot, 3);
+      fakeReceiveSlotManager.releaseSlot.getCalls().forEach((call) => {
+        const slot = call.args[0];
+
+        assert.strictEqual(slot.mediaType, MediaType.VideoMain);
+      });
+
+      await remoteMediaManager.setLayout('AllEqual');
+
+      assert.deepEqual(remoteMediaManager.slots.video.unused, []);
+
+      // checking that slots are in the same order as in previous layout + 3 new ones
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 10",
+        "fake video 11",
+        "fake video 12",
+      ]);
+
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["main"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 10",
+        "fake video 11",
+        "fake video 12"
+      ])
+
+       // verify that 3 main video slots were allocated
+       assert.callCount(fakeReceiveSlotManager.allocateSlot, 3);
+       fakeReceiveSlotManager.allocateSlot.getCalls().forEach((call) => {
+         const mediaType = call.args[0];
+
+         assert.strictEqual(mediaType, MediaType.VideoMain);
+       });
+    });
+
     it('stops all current video remoteMedia instances when switching to new layout', async () => {
       const audioStopStubs = [];
       const videoStopStubs = [];
@@ -1494,6 +1931,94 @@ describe('RemoteMediaManager', () => {
     });
   });
 
+  describe('setActiveSpeakerCsis', () => {
+    it('calls setActiveSpeakerCsis on the correct remote media group', async () => {
+      let currentLayoutInfo: VideoLayoutChangedEventData | null = null;
+      let setCsisStub;
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        currentLayoutInfo = layoutInfo;
+        setCsisStub = sinon.stub(layoutInfo.activeSpeakerVideoPanes.main, 'setActiveSpeakerCsis');
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+
+      assert.isNotNull(currentLayoutInfo);
+
+      if (currentLayoutInfo) {
+        const remoteVideo = currentLayoutInfo.activeSpeakerVideoPanes.main.getRemoteMedia()[0];
+
+        remoteMediaManager.setActiveSpeakerCsis([{remoteMedia: remoteVideo}]);
+
+        assert.calledOnce(setCsisStub);
+        assert.calledWith(setCsisStub, [{remoteMedia: remoteVideo}], false);
+        assert.calledOnce(fakeMediaRequestManagers.video.commit);
+      }
+    });
+
+    it('does not call setActiveSpeakerCsis on the incorrect media group', async () => {
+      let currentLayoutInfo: VideoLayoutChangedEventData | null = null;
+      let setCsisStub;
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        currentLayoutInfo = layoutInfo;
+        setCsisStub = sinon.stub(layoutInfo.activeSpeakerVideoPanes.main, 'setActiveSpeakerCsis');
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+
+      assert.isNotNull(currentLayoutInfo);
+
+      if (currentLayoutInfo) {
+        remoteMediaManager.setActiveSpeakerCsis([{remoteMedia: {}}]);
+
+        assert.notCalled(setCsisStub);
+        assert.calledOnce(fakeMediaRequestManagers.video.commit);
+      }
+    });
+
+    it('checking when there is more than one group', async () => {
+      let currentLayoutInfo: VideoLayoutChangedEventData | null = null;
+      const config = cloneDeep(DefaultTestConfiguration);
+      let stubs = [];
+
+      config.video.initialLayoutId = 'OnePlusFive';
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        currentLayoutInfo = layoutInfo;
+        Object.values(layoutInfo.activeSpeakerVideoPanes).forEach((group) => stubs.push(sinon.stub(group, 'setActiveSpeakerCsis')));
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+
+      assert.isNotNull(currentLayoutInfo);
+
+      if (currentLayoutInfo) {
+
+        const remoteMedia1 = currentLayoutInfo.activeSpeakerVideoPanes.mainBigOne.getRemoteMedia()[0];
+        const remoteMedia2 = currentLayoutInfo.activeSpeakerVideoPanes.secondarySetOfSmallPanes.getRemoteMedia()[0];
+
+        const remoteMediaCsis = [{remoteMedia: remoteMedia1}, {remoteMedia: remoteMedia2}];
+
+        remoteMediaManager.setActiveSpeakerCsis([{remoteMedia: remoteMedia1}, {remoteMedia: remoteMedia2}]);
+
+        stubs.forEach((stub, index) => {
+          assert.calledWith(stub, [remoteMediaCsis[index]], false)
+        });
+        assert.calledOnce(fakeMediaRequestManagers.video.commit);
+      }
+    });
+  });
+
   describe('pinActiveSpeakerVideoPane() and isPinned()', () => {
     it('throws if called on a pane not belonging to an active speaker group', async () => {
       let currentLayoutInfo: VideoLayoutChangedEventData | null = null;