@webex/plugin-meetings 3.0.0-beta.43 → 3.0.0-beta.45

package/src/meeting/muteState.ts

@@ -52,9 +52,9 @@ class MuteState {
       },
       server: {
         localMute: false,
-        // initial values available only for audio (REMOTE_MUTE_VIDEO_MISSING_IMPLEMENTATION)
-        remoteMute: type === AUDIO ? meeting.remoteMuted : false,
-        unmuteAllowed: type === AUDIO ? meeting.unmuteAllowed : true,
+        // because remoteVideoMuted and unmuteVideoAllowed are updated seperately, they might be undefined
+        remoteMute: type === AUDIO ? meeting.remoteMuted : meeting.remoteVideoMuted ?? false,
+        unmuteAllowed: type === AUDIO ? meeting.unmuteAllowed : meeting.unmuteVideoAllowed ?? true,
       },
       syncToServerInProgress: false,
     };
@@ -241,35 +241,28 @@ class MuteState {
    * @returns {Promise}
    */
   private sendRemoteMuteRequestToServer(meeting?: any) {
-    if (this.type === AUDIO) {
-      const remoteMute = this.state.client.localMute;
+    const remoteMute = this.state.client.localMute;
 
-      LoggerProxy.logger.info(
-        `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: sending remote mute:${remoteMute} to server`
-      );
+    LoggerProxy.logger.info(
+      `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: sending remote mute:${remoteMute} to server`
+    );
 
-      return meeting.members
-        .muteMember(meeting.members.selfId, remoteMute)
-        .then(() => {
-          LoggerProxy.logger.info(
-            `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: remote mute:${remoteMute} applied to server`
-          );
-
-          this.state.server.remoteMute = remoteMute;
-        })
-        .catch((remoteUpdateError) => {
-          LoggerProxy.logger.warn(
-            `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: failed to apply remote mute ${remoteMute} to server: ${remoteUpdateError}`
-          );
-
-          return Promise.reject(remoteUpdateError);
-        });
-    }
+    return meeting.members
+      .muteMember(meeting.members.selfId, remoteMute, this.type === AUDIO)
+      .then(() => {
+        LoggerProxy.logger.info(
+          `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: remote mute:${remoteMute} applied to server`
+        );
 
-    // for now we don't need to support remote muting of video (REMOTE_MUTE_VIDEO_MISSING_IMPLEMENTATION)
-    this.state.server.remoteMute = this.state.client.localMute;
+        this.state.server.remoteMute = remoteMute;
+      })
+      .catch((remoteUpdateError) => {
+        LoggerProxy.logger.warn(
+          `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: failed to apply remote mute ${remoteMute} to server: ${remoteUpdateError}`
+        );
 
-    return Promise.resolve();
+        return Promise.reject(remoteUpdateError);
+      });
   }
 
   /**
@@ -285,8 +278,12 @@ class MuteState {
     LoggerProxy.logger.info(
       `Meeting:muteState#handleServerRemoteMuteUpdate --> ${this.type}: updating server remoteMute to (${muted})`
     );
-    this.state.server.remoteMute = muted;
-    this.state.server.unmuteAllowed = unmuteAllowed;
+    if (muted !== undefined) {
+      this.state.server.remoteMute = muted;
+    }
+    if (unmuteAllowed !== undefined) {
+      this.state.server.unmuteAllowed = unmuteAllowed;
+    }
   }
 
   /**
@@ -330,6 +327,28 @@ class MuteState {
     );
   }
 
+  /**
+   * Returns true if the user is remotely muted
+   *
+   * @public
+   * @memberof MuteState
+   * @returns {Boolean}
+   */
+  public isRemotelyMuted() {
+    return this.state.server.remoteMute;
+  }
+
+  /**
+   * Returns true if unmute is allowed
+   *
+   * @public
+   * @memberof MuteState
+   * @returns {Boolean}
+   */
+  public isUnmuteAllowed() {
+    return this.state.server.unmuteAllowed;
+  }
+
   /**
    * Returns true if the user is locally muted
    *

package/src/meeting/util.ts

@@ -375,6 +375,21 @@ MeetingUtil.bothLeaveAndEndMeetingAvailable = (displayHints) =>
   displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
   displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING);
 
+MeetingUtil.canManageBreakout = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.BREAKOUT_MANAGEMENT);
+
+MeetingUtil.isSuppressBreakoutSupport = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.UCF_SUPPRESS_BREAKOUTS_SUPPORT);
+
+MeetingUtil.canAdmitLobbyToBreakout = (displayHints) =>
+  !displayHints.includes(DISPLAY_HINTS.DISABLE_LOBBY_TO_BREAKOUT);
+
+MeetingUtil.isBreakoutPreassignmentsEnabled = (displayHints) =>
+  !displayHints.includes(DISPLAY_HINTS.DISABLE_BREAKOUT_PREASSIGNMENTS);
+
+MeetingUtil.canUserAskForHelp = (displayHints) =>
+  !displayHints.includes(DISPLAY_HINTS.DISABLE_ASK_FOR_HELP);
+
 MeetingUtil.lockMeeting = (actions, request, locusUrl) => {
   if (actions && actions.canLock) {
     return request.lockMeeting({locusUrl, lock: true});

package/src/members/index.ts

@@ -733,15 +733,22 @@ export default class Members extends StatelessWebexPlugin {
   /**
    * Admits waiting members (invited guests to meeting)
    * @param {Array} memberIds
+   * @param {Object} sessionLocusUrls: {authorizingLocusUrl, mainLocusUrl}
    * @returns {Promise}
    * @public
    * @memberof Members
    */
-  public admitMembers(memberIds: Array<any>) {
+  public admitMembers(
+    memberIds: Array<any>,
+    sessionLocusUrls?: {authorizingLocusUrl: string; mainLocusUrl: string}
+  ) {
     if (isEmpty(memberIds)) {
       return Promise.reject(new ParameterError('No member ids provided to admit.'));
     }
-    const options = MembersUtil.generateAdmitMemberOptions(memberIds, this.locusUrl);
+    const options = {
+      sessionLocusUrls,
+      ...MembersUtil.generateAdmitMemberOptions(memberIds, this.locusUrl),
+    };
 
     return this.membersRequest.admitMember(options);
   }
@@ -773,11 +780,12 @@ export default class Members extends StatelessWebexPlugin {
    * Audio mutes another member in a meeting
    * @param {String} memberId
    * @param {boolean} [mute] default true
+   * @param {boolean} [isAudio] default true
    * @returns {Promise}
    * @public
    * @memberof Members
    */
-  public muteMember(memberId: string, mute = true) {
+  public muteMember(memberId: string, mute = true, isAudio = true) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError(
@@ -790,7 +798,7 @@ export default class Members extends StatelessWebexPlugin {
         new ParameterError('The member id must be defined to mute the member.')
       );
     }
-    const options = MembersUtil.generateMuteMemberOptions(memberId, mute, this.locusUrl);
+    const options = MembersUtil.generateMuteMemberOptions(memberId, mute, this.locusUrl, isAudio);
 
     return this.membersRequest.muteMember(options);
   }

package/src/members/util.ts

@@ -54,20 +54,31 @@ MembersUtil.getAddMemberBody = (options: any) => ({
 });
 
 /**
- * @param {Object} options with {memberIds}
+ * @param {Object} options with {memberIds, authorizingLocusUrl}
  * @returns {Object} admit with {memberIds}
  */
-MembersUtil.getAdmitMemberRequestBody = (options: any) => ({
-  admit: {participantIds: options.memberIds},
-});
+MembersUtil.getAdmitMemberRequestBody = (options: any) => {
+  const {memberIds, sessionLocusUrls} = options;
+  const body: any = {admit: {participantIds: memberIds}};
+  if (sessionLocusUrls) {
+    const {authorizingLocusUrl} = sessionLocusUrls;
+
+    return {authorizingLocusUrl, ...body};
+  }
+
+  return body;
+};
 
 /**
- * @param {Object} format with {memberIds, locusUrl}
+ * @param {Object} format with {memberIds, locusUrl, sessionLocusUrls}
  * @returns {Object} the request parameters (method, uri, body) needed to make a admitMember request
+ * if a host/cohost is in a breakout session, the locus url should be the main session locus url
  */
 MembersUtil.getAdmitMemberRequestParams = (format: any) => {
   const body = MembersUtil.getAdmitMemberRequestBody(format);
-  const uri = `${format.locusUrl}/${CONTROLS}`;
+  const {locusUrl, sessionLocusUrls} = format;
+  const baseUrl = sessionLocusUrls?.mainLocusUrl || locusUrl;
+  const uri = `${baseUrl}/${CONTROLS}`;
 
   return {
     method: HTTP_VERBS.PUT,
@@ -128,10 +139,11 @@ MembersUtil.generateRemoveMemberOptions = (removal, locusUrl) => ({
   locusUrl,
 });
 
-MembersUtil.generateMuteMemberOptions = (memberId, status, locusUrl) => ({
+MembersUtil.generateMuteMemberOptions = (memberId, status, locusUrl, isAudio) => ({
   memberId,
   muted: status,
   locusUrl,
+  isAudio,
 });
 
 MembersUtil.generateRaiseHandMemberOptions = (memberId, status, locusUrl) => ({
@@ -146,8 +158,9 @@ MembersUtil.generateLowerAllHandsMemberOptions = (requestingParticipantId, locus
 });
 
 MembersUtil.getMuteMemberRequestParams = (options) => {
+  const property = options.isAudio === false ? 'video' : 'audio';
   const body = {
-    audio: {
+    [property]: {
       muted: options.muted,
     },
   };

package/src/multistream/remoteMediaManager.ts

@@ -601,25 +601,37 @@ export class RemoteMediaManager extends EventsScope {
   }
 
   /**
-   * Allocates receive slots to all video panes in the current selected layout
+   * Allocates receive slots to all active speaker video panes
+   * in the current selected layout.
+   *
+   * Allocation tries to keep the same order of the slots between the previous
+   * layout and the new one. Sorting helps making sure that highest priority slots
+   * go in the same order in the new layout.
    */
-  private allocateSlotsToVideoPaneGroups() {
-    this.receiveSlotAllocations = {activeSpeaker: {}, receiverSelected: {}};
-
-    this.currentLayout?.activeSpeakerVideoPaneGroups?.forEach((group) => {
-      this.receiveSlotAllocations.activeSpeaker[group.id] = {slots: []};
-
-      for (let paneIndex = 0; paneIndex < group.numPanes; paneIndex += 1) {
-        // allocate a slot from the "unused" list
-        const freeSlot = this.slots.video.unused.pop();
-
-        if (freeSlot) {
-          this.slots.video.activeSpeaker.push(freeSlot);
-          this.receiveSlotAllocations.activeSpeaker[group.id].slots.push(freeSlot);
+  private allocateSlotsToActiveSpeakerPaneGroups() {
+    this.currentLayout?.activeSpeakerVideoPaneGroups
+      // sorting in descending order based on group priority
+      ?.sort((a, b) => (a.priority < b.priority ? 1 : -1))
+      ?.forEach((group) => {
+        this.receiveSlotAllocations.activeSpeaker[group.id] = {slots: []};
+
+        for (let paneIndex = 0; paneIndex < group.numPanes; paneIndex += 1) {
+          // allocate a slot from the "unused" list, by grabbing in same order (shift) as previous layout
+          const freeSlot = this.slots.video.unused.shift();
+
+          if (freeSlot) {
+            this.slots.video.activeSpeaker.push(freeSlot);
+            this.receiveSlotAllocations.activeSpeaker[group.id].slots.push(freeSlot);
+          }
         }
-      }
-    });
+      });
+  }
 
+  /**
+   * Allocates receive slots to all receiver selected video panes
+   * in the current selected layout
+   */
+  private allocateSlotsToReceiverSelectedVideoPaneGroups() {
     this.currentLayout?.memberVideoPanes?.forEach((memberPane) => {
       // check if there is existing slot for this csi
       const existingSlot = this.slots.video.receiverSelected.find(
@@ -646,19 +658,15 @@ export class RemoteMediaManager extends EventsScope {
   }
 
   /**
-   * Makes sure we have the right number of receive slots created for the current layout
-   * and allocates them to the right video panes / pane groups
-   *
-   * @returns {Promise}
+   * Ensures that we have enough slots for the current layout.
    */
-  private async updateVideoReceiveSlots() {
+  private async refillRequiredSlotsIfNeeded() {
     const requiredNumSlots = this.getRequiredNumVideoSlotsForLayout(this.currentLayout);
     const totalNumSlots =
       this.slots.video.unused.length +
       this.slots.video.activeSpeaker.length +
       this.slots.video.receiverSelected.length;
 
-    // ensure we have enough total slots for current layout
     if (totalNumSlots < requiredNumSlots) {
       let numSlotsToCreate = requiredNumSlots - totalNumSlots;
 
@@ -671,16 +679,39 @@ export class RemoteMediaManager extends EventsScope {
         numSlotsToCreate -= 1;
       }
     }
+  }
+
+  /**
+   * Move all active speaker slots to "unused"
+   */
+  private trimActiveSpeakerSlots() {
+    this.slots.video.unused.push(...this.slots.video.activeSpeaker);
+    this.slots.video.activeSpeaker.length = 0;
+  }
+
+  /**
+   * Makes sure we have the right number of receive slots created for the current layout
+   * and allocates them to the right video panes / pane groups
+   *
+   * @returns {Promise}
+   */
+  private async updateVideoReceiveSlots() {
+    // move all active speaker slots to "unused"
+    this.trimActiveSpeakerSlots();
 
     // move all no longer needed receiver-selected slots to "unused"
     this.trimReceiverSelectedSlots();
 
-    // move all active speaker slots to "unused"
-    this.slots.video.unused.push(...this.slots.video.activeSpeaker);
-    this.slots.video.activeSpeaker.length = 0;
+    // ensure we have enough total slots for current layout
+    await this.refillRequiredSlotsIfNeeded();
 
     // allocate the slots to the right panes / pane groups
-    this.allocateSlotsToVideoPaneGroups();
+    // reset allocations
+    this.receiveSlotAllocations = {activeSpeaker: {}, receiverSelected: {}};
+    // allocate active speaker
+    this.allocateSlotsToActiveSpeakerPaneGroups();
+    // allocate receiver selected
+    this.allocateSlotsToReceiverSelectedVideoPaneGroups();
 
     LoggerProxy.logger.log(
       `RemoteMediaManager#updateVideoReceiveSlots --> receive slots updated: unused=${this.slots.video.unused.length}, activeSpeaker=${this.slots.video.activeSpeaker.length}, receiverSelected=${this.slots.video.receiverSelected.length}`

package/test/unit/spec/breakouts/index.ts

@@ -511,8 +511,8 @@ describe('plugin-meetings', () => {
 
         assert.equal(arg.uri, 'url');
         assert.equal(arg.method, 'PUT');
-        assert.deepEqual(argObj1, {id:'groupId', action: 'START', allowBackToMain: false, allowToJoinLater: false});
-        assert.deepEqual(argObj2, {id:'id', action: 'START', allowBackToMain: false, allowToJoinLater: false, someOtherParam: 'someOtherParam'});
+        assert.deepEqual(argObj1, {id:'groupId', action: 'START', allowBackToMain: false, allowToJoinLater: false, duration: BREAKOUTS.DEFAULT_DURATION});
+        assert.deepEqual(argObj2, {id:'id', action: 'START', allowBackToMain: false, allowToJoinLater: false, someOtherParam: 'someOtherParam', duration: BREAKOUTS.DEFAULT_DURATION});
         assert.deepEqual(result, {body: getBOResponse('OPEN')});
       });
 

package/test/unit/spec/locus-info/controlsUtils.js

@@ -39,64 +39,122 @@ describe('plugin-meetings', () => {
 
         assert.equal(parsedControls.entryExitTone, null);
       });
-    });
-  });
 
-  describe('getControls', () => {
-    it('returns hasEntryExitToneChanged = true when mode changed', () => {
-      const newControls = {
-        entryExitTone: {
-          enabled: true,
-          mode: 'bar',
-        },
-      };
-      const {updates} = ControlsUtils.getControls(defaultControls, newControls);
-
-      assert.equal(updates.hasEntryExitToneChanged, true);
-    });
+      describe('videoEnabled', () => {
+        it('returns expected', () => {
+          const result = ControlsUtils.parse({video: {enabled: true}});
+          assert.deepEqual(result, {
+            video: {
+              enabled: true,
+            },
+            videoEnabled: true,
+          });
+        });
 
-    it('returns hasEntryExitToneChanged = true when enabled changed', () => {
-      const newControls = {
-        entryExitTone: {
-          enabled: false,
-          mode: 'foo',
-        },
-      };
-      const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+        it('returns expected from undefined', () => {
+          const result = ControlsUtils.parse();
+          assert.deepEqual(result, {});
+        });
 
-      assert.equal(updates.hasEntryExitToneChanged, true);
+        it('returns expected from undefined controls', () => {
+          const result = ControlsUtils.parse({});
+          assert.deepEqual(result, {});
+        });
+      });
     });
 
-    it('returns hasEntryExitToneChanged = false when nothing changed', () => {
-      const newControls = {
-        entryExitTone: {
-          enabled: true,
-          mode: 'foo',
-        },
-      };
-      const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+    describe('getControls', () => {
+      it('returns hasEntryExitToneChanged = true when mode changed', () => {
+        const newControls = {
+          entryExitTone: {
+            enabled: true,
+            mode: 'bar',
+          },
+        };
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
 
-      assert.equal(updates.hasEntryExitToneChanged, false);
-    });
+        assert.equal(updates.hasEntryExitToneChanged, true);
+      });
 
-    it('returns hasBreakoutChanged = true when it has changed', () => {
-      const newControls = {
-        breakout: 'breakout'
-      };
+      it('returns hasEntryExitToneChanged = true when enabled changed', () => {
+        const newControls = {
+          entryExitTone: {
+            enabled: false,
+            mode: 'foo',
+          },
+        };
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
 
-      const {updates} = ControlsUtils.getControls({breakout: 'old breakout'}, newControls);
+        assert.equal(updates.hasEntryExitToneChanged, true);
+      });
 
-      assert.equal(updates.hasBreakoutChanged, true);
-    });
+      it('returns hasEntryExitToneChanged = false when nothing changed', () => {
+        const newControls = {
+          entryExitTone: {
+            enabled: true,
+            mode: 'foo',
+          },
+        };
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasEntryExitToneChanged, false);
+      });
+
+      it('returns hasBreakoutChanged = true when it has changed', () => {
+        const newControls = {
+          breakout: 'breakout',
+        };
+
+        const {updates} = ControlsUtils.getControls({breakout: 'old breakout'}, newControls);
+
+        assert.equal(updates.hasBreakoutChanged, true);
+      });
 
-    it('returns hasBreakoutChanged = false when it has not changed', () => {
-      const newControls = {
-        breakout: 'breakout'
-      };
+      it('returns hasBreakoutChanged = false when it has not changed', () => {
+        const newControls = {
+          breakout: 'breakout',
+        };
 
-      const {updates} = ControlsUtils.getControls({breakout: 'breakout'}, newControls);
+        const {updates} = ControlsUtils.getControls({breakout: 'breakout'}, newControls);
 
-      assert.equal(updates.hasBreakoutChanged, false);
+        assert.equal(updates.hasBreakoutChanged, false);
+      });
+
+      describe('videoEnabled', () => {
+        const testVideoEnabled = (oldControls, newControls, updatedProperty) => {
+          const result = ControlsUtils.getControls(oldControls, newControls);
+
+          let expectedPrevious = oldControls;
+          if (Object.keys(oldControls).length) {
+            expectedPrevious = {
+              ...expectedPrevious,
+              ...{videoEnabled: oldControls.video.enabled},
+            };
+          }
+          const expectedCurrent = {...newControls, ...{videoEnabled: newControls.video.enabled}};
+
+          assert.deepEqual(result.previous, expectedPrevious);
+          assert.deepEqual(result.current, expectedCurrent);
+          if (updatedProperty !== undefined) {
+            assert.deepEqual(
+              result.updates.hasVideoEnabledChanged,
+              !isEqual(oldControls, newControls)
+            );
+          }
+        };
+
+        it('returns expected from undefined', () => {
+          testVideoEnabled({}, {video: {enabled: true}});
+        });
+
+        it('returns expected from defined', () => {
+          testVideoEnabled({video: {enabled: false}}, {video: {enabled: true}});
+        });
+
+        it('returns expected for unchanged', () => {
+          testVideoEnabled({video: {enabled: false}}, {video: {enabled: false}});
+        });
+      });
     });
   });
 });