@webex/plugin-meetings 3.0.0-beta.42 → 3.0.0-beta.44

package/src/locus-info/selfUtils.ts

@@ -32,6 +32,7 @@ SelfUtils.parse = (self: any, deviceId: string) => {
     const pstnDevices = self.devices.filter((device) => PSTN_DEVICE_TYPE === device.deviceType);
 
     return {
+      remoteVideoMuted: SelfUtils.getRemoteVideoMuted(self),
       remoteMuted: SelfUtils.getRemoteMuted(self),
       unmuteAllowed: SelfUtils.getUnmuteAllowed(self),
       localAudioUnmuteRequested: SelfUtils.getLocalAudioUnmuteRequested(self),
@@ -93,6 +94,7 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
 
   updates.isUserUnadmitted = SelfUtils.isUserUnadmitted(current);
   updates.isUserAdmitted = SelfUtils.isUserAdmitted(previous, current);
+  updates.isVideoMutedByOthersChanged = SelfUtils.videoMutedByOthersChanged(previous, current);
   updates.isMutedByOthersChanged = SelfUtils.mutedByOthersChanged(previous, current);
   updates.localAudioUnmuteRequestedByServer = SelfUtils.localAudioUnmuteRequestedByServer(
     previous,
@@ -236,6 +238,19 @@ SelfUtils.getSelfIdentity = (self: any) => {
   return self.person.id;
 };
 
+/**
+ * get the "remote video mute" property from the self object
+ * @param {Object} self
+ * @returns {Boolean}
+ */
+SelfUtils.getRemoteVideoMuted = (self: any) => {
+  if (!self || !self.controls || !self.controls.video) {
+    return null;
+  }
+
+  return self.controls.video.muted;
+};
+
 /**
  * get the "remote mute" property from the self object
  * @param {Object} self
@@ -351,6 +366,25 @@ SelfUtils.isUserAdmitted = (oldSelf: object, changedSelf: object) => {
   return SelfUtils.isLocusUserUnadmitted(oldSelf) && SelfUtils.isLocusUserAdmitted(changedSelf);
 };
 
+SelfUtils.videoMutedByOthersChanged = (oldSelf, changedSelf) => {
+  if (!changedSelf) {
+    throw new ParameterError(
+      'New self must be defined to determine if self was video muted by others.'
+    );
+  }
+
+  if (!oldSelf || oldSelf.remoteVideoMuted === null) {
+    if (changedSelf.remoteVideoMuted) {
+      return true; // this happens when host disables "Allow start video"
+    }
+
+    // we don't want to be sending the 'meeting:self:videoUnmutedByOthers' notification on meeting join
+    return false;
+  }
+
+  return oldSelf.remoteVideoMuted !== changedSelf.remoteVideoMuted;
+};
+
 SelfUtils.mutedByOthersChanged = (oldSelf, changedSelf) => {
   if (!changedSelf) {
     throw new ParameterError('New self must be defined to determine if self was muted by others.');

package/src/meeting/in-meeting-actions.ts

@@ -17,6 +17,8 @@ interface IInMeetingActions {
   canUnsetMuteOnEntry?: boolean;
   canSetDisallowUnmute?: boolean;
   canUnsetDisallowUnmute?: boolean;
+  canSetMuted?: boolean;
+  canUnsetMuted?: boolean;
   canAssignHost?: boolean;
   canStartRecording?: boolean;
   canPauseRecording?: boolean;
@@ -71,6 +73,10 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canUnsetDisallowUnmute = null;
 
+  canSetMuted = null;
+
+  canUnsetMuted = null;
+
   canRaiseHand = null;
 
   canLowerAllHands = null;
@@ -114,6 +120,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canSetMuteOnEntry: this.canSetMuteOnEntry,
     canUnsetMuteOnEntry: this.canUnsetMuteOnEntry,
     canSetDisallowUnmute: this.canSetDisallowUnmute,
+    canSetMuted: this.canSetMuted,
+    canUnsetMuted: this.canUnsetMuted,
     canUnsetDisallowUnmute: this.canUnsetDisallowUnmute,
     canStartRecording: this.canStartRecording,
     canPauseRecording: this.canPauseRecording,

package/src/meeting/index.ts

@@ -17,7 +17,6 @@ import {
 
 import {
   MeetingNotActiveError,
-  createMeetingsError,
   UserInLobbyError,
   NoMediaEstablishedYetError,
   UserNotJoinedError,
@@ -2290,6 +2289,8 @@ export default class Meeting extends StatelessWebexPlugin {
           canUnsetMuteOnEntry: ControlsOptionsUtil.canUnsetMuteOnEntry(
             payload.info.userDisplayHints
           ),
+          canSetMuted: ControlsOptionsUtil.canSetMuted(payload.info.userDisplayHints),
+          canUnsetMuted: ControlsOptionsUtil.canUnsetMuted(payload.info.userDisplayHints),
           canStartRecording: RecordingUtil.canUserStart(payload.info.userDisplayHints),
           canStopRecording: RecordingUtil.canUserStop(payload.info.userDisplayHints),
           canPauseRecording: RecordingUtil.canUserPause(payload.info.userDisplayHints),
@@ -2406,6 +2407,30 @@ export default class Meeting extends StatelessWebexPlugin {
         );
       }
     });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED, (payload) => {
+      if (payload) {
+        if (this.video) {
+          payload.muted = payload.muted ?? this.video.isRemotelyMuted();
+          payload.unmuteAllowed = payload.unmuteAllowed ?? this.video.isUnmuteAllowed();
+          this.video.handleServerRemoteMuteUpdate(payload.muted, payload.unmuteAllowed);
+        }
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setUpLocusInfoSelfListener',
+          },
+          payload.muted
+            ? EVENT_TRIGGERS.MEETING_SELF_VIDEO_MUTED_BY_OTHERS
+            : EVENT_TRIGGERS.MEETING_SELF_VIDEO_UNMUTED_BY_OTHERS,
+          {
+            payload,
+          }
+        );
+      }
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED, (payload) => {
       if (payload) {
         if (this.audio) {
@@ -2693,14 +2718,32 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Admit the guest(s) to the call once they are waiting
+   * Admit the guest(s) to the call once they are waiting.
+   * If the host/cohost is in a breakout session, the locus url
+   * of the session must be provided as the authorizingLocusUrl.
+   * Regardless of host/cohost location, the locus Id (lid) in
+   * the path should be the locus Id of the main, which means the
+   * locus url of the api call must be from the main session.
+   * If these loucs urls are not provided, the function will do the check.
    * @param {Array} memberIds
+   * @param {Object} sessionLocusUrls: {authorizingLocusUrl, mainLocusUrl}
    * @returns {Promise} see #members.admitMembers
    * @public
    * @memberof Meeting
    */
-  public admit(memberIds: Array<any>) {
-    return this.members.admitMembers(memberIds);
+  public admit(
+    memberIds: Array<any>,
+    sessionLocusUrls?: {authorizingLocusUrl: string; mainLocusUrl: string}
+  ) {
+    let locusUrls = sessionLocusUrls;
+    if (!locusUrls) {
+      const {locusUrl, mainLocusUrl} = this.breakouts;
+      if (locusUrl && mainLocusUrl) {
+        locusUrls = {authorizingLocusUrl: locusUrl, mainLocusUrl};
+      }
+    }
+
+    return this.members.admitMembers(memberIds, locusUrls);
   }
 
   /**
@@ -6216,6 +6259,27 @@ export default class Meeting extends StatelessWebexPlugin {
     return this.controlsOptionsManager.setDisallowUnmute(enabled);
   }
 
+  /**
+   * set the mute all flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} mutedEnabled
+   * @param {boolean} disallowUnmuteEnabled
+   * @param {boolean} muteOnEntryEnabled
+   * @public
+   * @memberof Meeting
+   */
+  public setMuteAll(
+    mutedEnabled: boolean,
+    disallowUnmuteEnabled: boolean,
+    muteOnEntryEnabled: boolean
+  ) {
+    return this.controlsOptionsManager.setMuteAll(
+      mutedEnabled,
+      disallowUnmuteEnabled,
+      muteOnEntryEnabled
+    );
+  }
+
   /**
    * End the recording of this meeting
    * @returns {Promise}

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/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/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/controls-options-manager/index.js

@@ -119,6 +119,62 @@ describe('plugin-meetings', () => {
                     });
                   });
             });
+
+            describe('Mute/Unmute All', () => {
+              let manager;
+              beforeEach(() => {
+                request = {
+                  request: sinon.stub().returns(Promise.resolve()),
+                };
+
+                manager = new ControlsOptionsManager(request);
+
+                manager.set({
+                  locusUrl: 'test/id',
+                  displayHints: [],
+                })
+              });
+
+              it('rejects when correct display hint is not present mutedEnabled=false', () => {  
+                const result = manager.setMuteAll(false, false, false);
+
+                assert.notCalled(request.request);
+
+                assert.isRejected(result);
+              });
+
+              it('rejects when correct display hint is not present mutedEnabled=true', () => {  
+                const result = manager.setMuteAll(true, false, false);
+
+                assert.notCalled(request.request);
+
+                assert.isRejected(result);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=true', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'ENABLE_HARD_MUTE', 'ENABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(true, true, true);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=false', () => {
+                manager.setDisplayHints(['UNMUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(false, false, false);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: false, disallowUnmute: false, muteOnEntry: false } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+            });
           });
     });
 });

package/test/unit/spec/controls-options-manager/util.js

@@ -61,6 +61,26 @@ describe('plugin-meetings', () => {
               });
             });
 
+            describe('canSetMuteAll', () => {
+              it('can mute all', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('MUTE_ALL');
+
+                assert.equal(ControlsOptionsUtil.canSetMuted(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can unmute all', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('UNMUTE_ALL');
+
+                assert.equal(ControlsOptionsUtil.canUnsetMuted(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canSetMuted(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetMuted(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
         });
     });
 });