@webex/plugin-meetings 3.0.0-beta.201 → 3.0.0-beta.203

package/src/meeting/index.ts

@@ -1,5 +1,5 @@
 import uuid from 'uuid';
-import {cloneDeep, isEqual, defer, isEmpty} from 'lodash';
+import {cloneDeep, isEqual, isEmpty} from 'lodash';
 import jwt from 'jsonwebtoken';
 // @ts-ignore - Fix this
 import {StatelessWebexPlugin} from '@webex/webex-core';
@@ -483,6 +483,7 @@ export default class Meeting extends StatelessWebexPlugin {
   userId: string;
   video: any;
   callEvents: any[];
+  datachannelUrl: string;
   deferJoin: Promise<any>;
   dialInDeviceStatus: string;
   dialInUrl: string;
@@ -525,6 +526,7 @@ export default class Meeting extends StatelessWebexPlugin {
   statsAnalyzer: StatsAnalyzer;
   transcription: Transcription;
   updateMediaConnections: (mediaConnections: any[]) => void;
+  userDisplayHints: any;
   endCallInitJoinReq: any;
   endJoinReqResp: any;
   endLocalSDPGenRemoteSDPRecvDelay: any;
@@ -1348,8 +1350,12 @@ export default class Meeting extends StatelessWebexPlugin {
         EVENT_TRIGGERS.MEETING_INFO_AVAILABLE
       );
 
+      this.updateMeetingActions();
+
       return Promise.resolve();
     } catch (err) {
+      this.updateMeetingActions();
+
       if (err instanceof MeetingInfoV2PolicyError) {
         this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.POLICY;
         this.meetingInfoFailureCode = err.wbxAppApiCode;
@@ -2393,6 +2399,16 @@ export default class Meeting extends StatelessWebexPlugin {
       this.locusId = this.locusUrl?.split('/').pop();
       this.recordingController.setLocusUrl(this.locusUrl);
       this.controlsOptionsManager.setLocusUrl(this.locusUrl);
+
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpLocusSelfListener',
+        },
+        EVENT_TRIGGERS.MEETING_LOCUS_URL_UPDATE,
+        {locusUrl: payload}
+      );
     });
   }
 
@@ -2452,230 +2468,12 @@ export default class Meeting extends StatelessWebexPlugin {
         );
       }
     });
-    this.locusInfo.on(LOCUSINFO.EVENTS.MEETING_INFO_UPDATED, (payload) => {
-      if (payload && payload.info) {
-        const changed = this.inMeetingActions.set({
-          canInviteNewParticipants: MeetingUtil.canInviteNewParticipants(
-            payload.info.userDisplayHints
-          ),
-          canAdmitParticipant: MeetingUtil.canAdmitParticipant(payload.info.userDisplayHints),
-          canLock: MeetingUtil.canUserLock(payload.info.userDisplayHints),
-          canUnlock: MeetingUtil.canUserUnlock(payload.info.userDisplayHints),
-          canSetDisallowUnmute: ControlsOptionsUtil.canSetDisallowUnmute(
-            payload.info.userDisplayHints
-          ),
-          canUnsetDisallowUnmute: ControlsOptionsUtil.canUnsetDisallowUnmute(
-            payload.info.userDisplayHints
-          ),
-          canSetMuteOnEntry: ControlsOptionsUtil.canSetMuteOnEntry(payload.info.userDisplayHints),
-          canUnsetMuteOnEntry: ControlsOptionsUtil.canUnsetMuteOnEntry(
-            payload.info.userDisplayHints
-          ),
-          canSetMuted: ControlsOptionsUtil.canSetMuted(payload.info.userDisplayHints),
-          canUnsetMuted: ControlsOptionsUtil.canUnsetMuted(payload.info.userDisplayHints),
-          canStartRecording: RecordingUtil.canUserStart(
-            payload.info.userDisplayHints,
-            this.selfUserPolicies
-          ),
-          canStopRecording: RecordingUtil.canUserStop(
-            payload.info.userDisplayHints,
-            this.selfUserPolicies
-          ),
-          canPauseRecording: RecordingUtil.canUserPause(
-            payload.info.userDisplayHints,
-            this.selfUserPolicies
-          ),
-          canResumeRecording: RecordingUtil.canUserResume(
-            payload.info.userDisplayHints,
-            this.selfUserPolicies
-          ),
-          canRaiseHand: MeetingUtil.canUserRaiseHand(payload.info.userDisplayHints),
-          canLowerAllHands: MeetingUtil.canUserLowerAllHands(payload.info.userDisplayHints),
-          canLowerSomeoneElsesHand: MeetingUtil.canUserLowerSomeoneElsesHand(
-            payload.info.userDisplayHints
-          ),
-          bothLeaveAndEndMeetingAvailable: MeetingUtil.bothLeaveAndEndMeetingAvailable(
-            payload.info.userDisplayHints
-          ),
-          canEnableClosedCaption: MeetingUtil.canEnableClosedCaption(payload.info.userDisplayHints),
-          canStartTranscribing: MeetingUtil.canStartTranscribing(payload.info.userDisplayHints),
-          canStopTranscribing: MeetingUtil.canStopTranscribing(payload.info.userDisplayHints),
-          isClosedCaptionActive: MeetingUtil.isClosedCaptionActive(payload.info.userDisplayHints),
-          isSaveTranscriptsEnabled: MeetingUtil.isSaveTranscriptsEnabled(
-            payload.info.userDisplayHints
-          ),
-          isWebexAssistantActive: MeetingUtil.isWebexAssistantActive(payload.info.userDisplayHints),
-          canViewCaptionPanel: MeetingUtil.canViewCaptionPanel(payload.info.userDisplayHints),
-          isRealTimeTranslationEnabled: MeetingUtil.isRealTimeTranslationEnabled(
-            payload.info.userDisplayHints
-          ),
-          canSelectSpokenLanguages: MeetingUtil.canSelectSpokenLanguages(
-            payload.info.userDisplayHints
-          ),
-          waitingForOthersToJoin: MeetingUtil.waitingForOthersToJoin(payload.info.userDisplayHints),
-          canSendReactions: MeetingUtil.canSendReactions(
-            this.inMeetingActions.canSendReactions,
-            payload.info.userDisplayHints
-          ),
-          canManageBreakout: MeetingUtil.canManageBreakout(payload.info.userDisplayHints),
-          canBroadcastMessageToBreakout: MeetingUtil.canBroadcastMessageToBreakout(
-            payload.info.userDisplayHints,
-            this.selfUserPolicies
-          ),
-          canAdmitLobbyToBreakout: MeetingUtil.canAdmitLobbyToBreakout(
-            payload.info.userDisplayHints
-          ),
-          isBreakoutPreassignmentsEnabled: MeetingUtil.isBreakoutPreassignmentsEnabled(
-            payload.info.userDisplayHints
-          ),
-          canUserAskForHelp: MeetingUtil.canUserAskForHelp(payload.info.userDisplayHints),
-          canUserRenameSelfAndObserved: MeetingUtil.canUserRenameSelfAndObserved(
-            payload.info.userDisplayHints
-          ),
-          canUserRenameOthers: MeetingUtil.canUserRenameOthers(payload.info.userDisplayHints),
-          canMuteAll: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.MUTE_ALL],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canUnmuteAll: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.UNMUTE_ALL],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canEnableHardMute: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.ENABLE_HARD_MUTE],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canDisableHardMute: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.DISABLE_HARD_MUTE],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canEnableMuteOnEntry: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canDisableMuteOnEntry: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canEnableReactions: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.ENABLE_REACTIONS],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canDisableReactions: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.DISABLE_REACTIONS],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canEnableReactionDisplayNames: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canDisableReactionDisplayNames: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.DISABLE_SHOW_DISPLAY_NAME],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canUpdateShareControl: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.SHARE_CONTROL],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canEnableViewTheParticipantsList: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canDisableViewTheParticipantsList: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canEnableRaiseHand: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.ENABLE_RAISE_HAND],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canDisableRaiseHand: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.DISABLE_RAISE_HAND],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canEnableVideo: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.ENABLE_VIDEO],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canDisableVideo: ControlsOptionsUtil.hasHints({
-            requiredHints: [DISPLAY_HINTS.DISABLE_VIDEO],
-            displayHints: payload.info.userDisplayHints,
-          }),
-          canShareFile:
-            ControlsOptionsUtil.hasHints({
-              requiredHints: [DISPLAY_HINTS.SHARE_FILE],
-              displayHints: payload.info.userDisplayHints,
-            }) &&
-            ControlsOptionsUtil.hasPolicies({
-              requiredPolicies: [SELF_POLICY.SUPPORT_FILE_SHARE],
-              policies: this.selfUserPolicies,
-            }),
-          canTransferFile: ControlsOptionsUtil.hasPolicies({
-            requiredPolicies: [SELF_POLICY.SUPPORT_FILE_TRANSFER],
-            policies: this.selfUserPolicies,
-          }),
-          canShareApplication:
-            (ControlsOptionsUtil.hasHints({
-              requiredHints: [DISPLAY_HINTS.SHARE_APPLICATION],
-              displayHints: payload.info.userDisplayHints,
-            }) &&
-              (ControlsOptionsUtil.hasPolicies({
-                requiredPolicies: [SELF_POLICY.SUPPORT_APP_SHARE],
-                policies: this.selfUserPolicies,
-              }) ||
-                // @ts-ignore
-                !this.config.experimental.enableUnifiedMeetings)) ||
-            this.isLocusCall(),
-          canShareCamera:
-            ControlsOptionsUtil.hasHints({
-              requiredHints: [DISPLAY_HINTS.SHARE_CAMERA],
-              displayHints: payload.info.userDisplayHints,
-            }) &&
-            ControlsOptionsUtil.hasPolicies({
-              requiredPolicies: [SELF_POLICY.SUPPORT_CAMERA_SHARE],
-              policies: this.selfUserPolicies,
-            }),
-          canShareDesktop:
-            (ControlsOptionsUtil.hasHints({
-              requiredHints: [DISPLAY_HINTS.SHARE_DESKTOP],
-              displayHints: payload.info.userDisplayHints,
-            }) &&
-              (ControlsOptionsUtil.hasPolicies({
-                requiredPolicies: [SELF_POLICY.SUPPORT_DESKTOP_SHARE],
-                policies: this.selfUserPolicies,
-              }) ||
-                // @ts-ignore
-                !this.config.experimental.enableUnifiedMeetings)) ||
-            this.isLocusCall(),
-          canShareContent:
-            ControlsOptionsUtil.hasHints({
-              requiredHints: [DISPLAY_HINTS.SHARE_CONTENT],
-              displayHints: payload.info.userDisplayHints,
-            }) || this.isLocusCall(),
-          canAnnotate: ControlsOptionsUtil.hasPolicies({
-            requiredPolicies: [SELF_POLICY.SUPPORT_ANNOTATION],
-            policies: this.selfUserPolicies,
-          }),
-        });
-
-        this.recordingController.setDisplayHints(payload.info.userDisplayHints);
-        this.recordingController.setUserPolicy(this.selfUserPolicies);
-        this.controlsOptionsManager.setDisplayHints(payload.info.userDisplayHints);
-
-        if (changed) {
-          Trigger.trigger(
-            this,
-            {
-              file: 'meeting/index',
-              function: 'setUpLocusInfoMeetingInfoListener',
-            },
-            EVENT_TRIGGERS.MEETING_ACTIONS_UPDATE,
-            this.inMeetingActions.get()
-          );
-        }
-
-        this.handleDataChannelUrlChange(payload.info.datachannelUrl);
-      }
+    this.locusInfo.on(LOCUSINFO.EVENTS.MEETING_INFO_UPDATED, () => {
+      this.updateMeetingActions();
+      this.recordingController.setDisplayHints(this.userDisplayHints);
+      this.recordingController.setUserPolicy(this.selfUserPolicies);
+      this.controlsOptionsManager.setDisplayHints(this.userDisplayHints);
+      this.handleDataChannelUrlChange(this.datachannelUrl);
     });
   }
 
@@ -2684,15 +2482,10 @@ export default class Meeting extends StatelessWebexPlugin {
    * @param {String} datachannelUrl
    * @returns {void}
    */
-
   handleDataChannelUrlChange(datachannelUrl) {
     // @ts-ignore - config coming from registerPlugin
     if (datachannelUrl && this.config.enableAutomaticLLM) {
-      // Defer this as updateLLMConnection relies upon this.locusInfo.url which is only set
-      // after the MEETING_INFO_UPDATED callback finishes
-      defer(() => {
-        this.updateLLMConnection();
-      });
+      this.updateLLMConnection();
     }
   }
 
@@ -3234,6 +3027,250 @@ export default class Meeting extends StatelessWebexPlugin {
     MeetingUtil.parseInterpretationInfo(this, webexMeetingInfo);
   }
 
+  /**
+   * Indicates whether policy can be applied
+   * @returns {boolean}
+   */
+  private arePolicyRestrictionsSupported() {
+    // Locus calls do not return the correct display hints
+    if (this.isLocusCall()) {
+      return false;
+    }
+
+    // 1-2-1 calls and SIP dialling will have no meeting info
+    // so cannot support policy information
+    if (isEmpty(this.meetingInfo)) {
+      return false;
+    }
+
+    // Old locus info api does not return policy information
+    // @ts-ignore
+    if (!this.config.experimental.enableUnifiedMeetings) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Updates the meeting actions (display hints), depends on locus display hints, user policy and app api info
+   * @returns {undefined}
+   * @private
+   * @memberof Meeting
+   */
+  private updateMeetingActions() {
+    let changed = false;
+    changed = this.inMeetingActions.set({
+      canUseVoip:
+        ((this.userDisplayHints !== undefined
+          ? ControlsOptionsUtil.hasHints({
+              requiredHints: [DISPLAY_HINTS.VOIP_IS_ENABLED],
+              displayHints: this.userDisplayHints,
+            })
+          : this.meetingInfo?.supportVoIP === true) &&
+          ControlsOptionsUtil.hasPolicies({
+            requiredPolicies: [SELF_POLICY.SUPPORT_VOIP],
+            policies: this.selfUserPolicies,
+          })) ||
+        !this.arePolicyRestrictionsSupported(),
+    });
+    if (this.userDisplayHints !== undefined) {
+      changed =
+        this.inMeetingActions.set({
+          canInviteNewParticipants: MeetingUtil.canInviteNewParticipants(this.userDisplayHints),
+          canAdmitParticipant: MeetingUtil.canAdmitParticipant(this.userDisplayHints),
+          canLock: MeetingUtil.canUserLock(this.userDisplayHints),
+          canUnlock: MeetingUtil.canUserUnlock(this.userDisplayHints),
+          canSetDisallowUnmute: ControlsOptionsUtil.canSetDisallowUnmute(this.userDisplayHints),
+          canUnsetDisallowUnmute: ControlsOptionsUtil.canUnsetDisallowUnmute(this.userDisplayHints),
+          canSetMuteOnEntry: ControlsOptionsUtil.canSetMuteOnEntry(this.userDisplayHints),
+          canUnsetMuteOnEntry: ControlsOptionsUtil.canUnsetMuteOnEntry(this.userDisplayHints),
+          canSetMuted: ControlsOptionsUtil.canSetMuted(this.userDisplayHints),
+          canUnsetMuted: ControlsOptionsUtil.canUnsetMuted(this.userDisplayHints),
+          canStartRecording: RecordingUtil.canUserStart(
+            this.userDisplayHints,
+            this.selfUserPolicies
+          ),
+          canStopRecording: RecordingUtil.canUserStop(this.userDisplayHints, this.selfUserPolicies),
+          canPauseRecording: RecordingUtil.canUserPause(
+            this.userDisplayHints,
+            this.selfUserPolicies
+          ),
+          canResumeRecording: RecordingUtil.canUserResume(
+            this.userDisplayHints,
+            this.selfUserPolicies
+          ),
+          canRaiseHand: MeetingUtil.canUserRaiseHand(this.userDisplayHints),
+          canLowerAllHands: MeetingUtil.canUserLowerAllHands(this.userDisplayHints),
+          canLowerSomeoneElsesHand: MeetingUtil.canUserLowerSomeoneElsesHand(this.userDisplayHints),
+          bothLeaveAndEndMeetingAvailable: MeetingUtil.bothLeaveAndEndMeetingAvailable(
+            this.userDisplayHints
+          ),
+          canEnableClosedCaption: MeetingUtil.canEnableClosedCaption(this.userDisplayHints),
+          canStartTranscribing: MeetingUtil.canStartTranscribing(this.userDisplayHints),
+          canStopTranscribing: MeetingUtil.canStopTranscribing(this.userDisplayHints),
+          isClosedCaptionActive: MeetingUtil.isClosedCaptionActive(this.userDisplayHints),
+          isSaveTranscriptsEnabled: MeetingUtil.isSaveTranscriptsEnabled(this.userDisplayHints),
+          isWebexAssistantActive: MeetingUtil.isWebexAssistantActive(this.userDisplayHints),
+          canViewCaptionPanel: MeetingUtil.canViewCaptionPanel(this.userDisplayHints),
+          isRealTimeTranslationEnabled: MeetingUtil.isRealTimeTranslationEnabled(
+            this.userDisplayHints
+          ),
+          canSelectSpokenLanguages: MeetingUtil.canSelectSpokenLanguages(this.userDisplayHints),
+          waitingForOthersToJoin: MeetingUtil.waitingForOthersToJoin(this.userDisplayHints),
+          canSendReactions: MeetingUtil.canSendReactions(
+            this.inMeetingActions.canSendReactions,
+            this.userDisplayHints
+          ),
+          canManageBreakout: MeetingUtil.canManageBreakout(this.userDisplayHints),
+          canBroadcastMessageToBreakout: MeetingUtil.canBroadcastMessageToBreakout(
+            this.userDisplayHints,
+            this.selfUserPolicies
+          ),
+          canAdmitLobbyToBreakout: MeetingUtil.canAdmitLobbyToBreakout(this.userDisplayHints),
+          isBreakoutPreassignmentsEnabled: MeetingUtil.isBreakoutPreassignmentsEnabled(
+            this.userDisplayHints
+          ),
+          canUserAskForHelp: MeetingUtil.canUserAskForHelp(this.userDisplayHints),
+          canUserRenameSelfAndObserved: MeetingUtil.canUserRenameSelfAndObserved(
+            this.userDisplayHints
+          ),
+          canUserRenameOthers: MeetingUtil.canUserRenameOthers(this.userDisplayHints),
+          canMuteAll: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.MUTE_ALL],
+            displayHints: this.userDisplayHints,
+          }),
+          canUnmuteAll: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.UNMUTE_ALL],
+            displayHints: this.userDisplayHints,
+          }),
+          canEnableHardMute: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_HARD_MUTE],
+            displayHints: this.userDisplayHints,
+          }),
+          canDisableHardMute: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_HARD_MUTE],
+            displayHints: this.userDisplayHints,
+          }),
+          canEnableMuteOnEntry: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY],
+            displayHints: this.userDisplayHints,
+          }),
+          canDisableMuteOnEntry: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY],
+            displayHints: this.userDisplayHints,
+          }),
+          canEnableReactions: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_REACTIONS],
+            displayHints: this.userDisplayHints,
+          }),
+          canDisableReactions: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_REACTIONS],
+            displayHints: this.userDisplayHints,
+          }),
+          canEnableReactionDisplayNames: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME],
+            displayHints: this.userDisplayHints,
+          }),
+          canDisableReactionDisplayNames: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_SHOW_DISPLAY_NAME],
+            displayHints: this.userDisplayHints,
+          }),
+          canUpdateShareControl: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHARE_CONTROL],
+            displayHints: this.userDisplayHints,
+          }),
+          canEnableViewTheParticipantsList: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST],
+            displayHints: this.userDisplayHints,
+          }),
+          canDisableViewTheParticipantsList: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST],
+            displayHints: this.userDisplayHints,
+          }),
+          canEnableRaiseHand: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_RAISE_HAND],
+            displayHints: this.userDisplayHints,
+          }),
+          canDisableRaiseHand: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_RAISE_HAND],
+            displayHints: this.userDisplayHints,
+          }),
+          canEnableVideo: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIDEO],
+            displayHints: this.userDisplayHints,
+          }),
+          canDisableVideo: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_VIDEO],
+            displayHints: this.userDisplayHints,
+          }),
+          canShareFile:
+            (ControlsOptionsUtil.hasHints({
+              requiredHints: [DISPLAY_HINTS.SHARE_FILE],
+              displayHints: this.userDisplayHints,
+            }) &&
+              ControlsOptionsUtil.hasPolicies({
+                requiredPolicies: [SELF_POLICY.SUPPORT_FILE_SHARE],
+                policies: this.selfUserPolicies,
+              })) ||
+            !this.arePolicyRestrictionsSupported,
+          canTransferFile: ControlsOptionsUtil.hasPolicies({
+            requiredPolicies: [SELF_POLICY.SUPPORT_FILE_TRANSFER],
+            policies: this.selfUserPolicies,
+          }),
+          canShareApplication:
+            (ControlsOptionsUtil.hasHints({
+              requiredHints: [DISPLAY_HINTS.SHARE_APPLICATION],
+              displayHints: this.userDisplayHints,
+            }) &&
+              ControlsOptionsUtil.hasPolicies({
+                requiredPolicies: [SELF_POLICY.SUPPORT_APP_SHARE],
+                policies: this.selfUserPolicies,
+              })) ||
+            !this.arePolicyRestrictionsSupported(),
+          canShareCamera:
+            ControlsOptionsUtil.hasHints({
+              requiredHints: [DISPLAY_HINTS.SHARE_CAMERA],
+              displayHints: this.userDisplayHints,
+            }) &&
+            ControlsOptionsUtil.hasPolicies({
+              requiredPolicies: [SELF_POLICY.SUPPORT_CAMERA_SHARE],
+              policies: this.selfUserPolicies,
+            }),
+          canShareDesktop:
+            (ControlsOptionsUtil.hasHints({
+              requiredHints: [DISPLAY_HINTS.SHARE_DESKTOP],
+              displayHints: this.userDisplayHints,
+            }) &&
+              ControlsOptionsUtil.hasPolicies({
+                requiredPolicies: [SELF_POLICY.SUPPORT_DESKTOP_SHARE],
+                policies: this.selfUserPolicies,
+              })) ||
+            !this.arePolicyRestrictionsSupported(),
+          canShareContent:
+            ControlsOptionsUtil.hasHints({
+              requiredHints: [DISPLAY_HINTS.SHARE_CONTENT],
+              displayHints: this.userDisplayHints,
+            }) || !this.arePolicyRestrictionsSupported(),
+          canAnnotate: ControlsOptionsUtil.hasPolicies({
+            requiredPolicies: [SELF_POLICY.SUPPORT_ANNOTATION],
+            policies: this.selfUserPolicies,
+          }),
+        }) || changed;
+    }
+    if (changed) {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'updateMeetingActions',
+        },
+        EVENT_TRIGGERS.MEETING_ACTIONS_UPDATE,
+        this.inMeetingActions.get()
+      );
+    }
+  }
+
   /**
    * Sets the self user policies based on the contents of the permission token
    * @param {String} permissionToken

package/src/recording-controller/index.ts

@@ -89,7 +89,6 @@ export default class RecordingController {
 
   /**
    * @param {MeetingRequest} request
-   * @param {LocusInfo} info
    * @returns {void}
    * @private
    * @memberof RecordingController

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

@@ -1378,7 +1378,6 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
-          {info: locusInfo.parsedLocus.info, self},
         ];
 
         if (expected) {
@@ -1407,15 +1406,40 @@ describe('plugin-meetings', () => {
         locusInfo.emitScoped.resetHistory();
       };
 
-      it('emits MEETING_INFO_UPDATED if the info changes', () => {
+      it('emits MEETING_INFO_UPDATED and updates the meeting if the info changes', () => {
         const initialInfo = cloneDeep(meetingInfo);
 
-        locusInfo.emitScoped = sinon.stub();
+        let expectedMeeting;
+
+        /*
+        When the event is triggered, it is required that the meeting has already
+        been updated. This is why the meeting is being checked within the stubbed event emitter
+        */
+        sinon.stub(locusInfo, 'emitScoped').callsFake(() => {
+          assert.deepEqual(mockMeeting, expectedMeeting);
+        })
+
 
         // set the info initially as locusInfo.info starts as undefined
+        expectedMeeting = {
+          coHost: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+          },
+          isLocked: false,
+          isUnlocked: true,
+          moderator: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+          },
+          policy: {
+            LOCK_STATUS_UNLOCKED: true,
+            ROSTER_IN_MEETING: true,
+          },
+          userDisplayHints: ['ROSTER_IN_MEETING', 'LOCK_STATUS_UNLOCKED'],
+        };
         locusInfo.updateMeetingInfo(initialInfo, self);
 
         // since it was initially undefined, this should trigger the event
+
         checkMeetingInfoUpdatedCalled(true);
 
         const newInfo = cloneDeep(meetingInfo);
@@ -1423,11 +1447,43 @@ describe('plugin-meetings', () => {
         newInfo.displayHints.coHost = [DISPLAY_HINTS.LOCK_CONTROL_LOCK];
 
         // Updating with different info should trigger the event
+        expectedMeeting = {
+          coHost: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+            LOCK_CONTROL_LOCK: true,
+          },
+          isLocked: false,
+          isUnlocked: true,
+          moderator: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+          },
+          policy: {
+            LOCK_STATUS_UNLOCKED: true,
+            ROSTER_IN_MEETING: true,
+          },
+          userDisplayHints: ['ROSTER_IN_MEETING', 'LOCK_STATUS_UNLOCKED'],
+        };
         locusInfo.updateMeetingInfo(newInfo, self);
 
         checkMeetingInfoUpdatedCalled(true);
 
         // update it with the same info
+        expectedMeeting = {
+          coHost: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+            LOCK_CONTROL_LOCK: true,
+          },
+          isLocked: false,
+          isUnlocked: true,
+          moderator: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+          },
+          policy: {
+            LOCK_STATUS_UNLOCKED: true,
+            ROSTER_IN_MEETING: true,
+          },
+          userDisplayHints: ['ROSTER_IN_MEETING', 'LOCK_STATUS_UNLOCKED'],
+        };
         locusInfo.updateMeetingInfo(newInfo, self);
 
         // since the info is the same it should not call trigger the event
@@ -1439,6 +1495,27 @@ describe('plugin-meetings', () => {
           type: 'COHOST',
           hasRole: true,
         });
+        expectedMeeting = {
+          coHost: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+            LOCK_CONTROL_LOCK: true,
+          },
+          isLocked: false,
+          isUnlocked: true,
+          moderator: {
+            LOWER_SOMEONE_ELSES_HAND: true,
+          },
+          policy: {
+            LOCK_STATUS_UNLOCKED: true,
+            ROSTER_IN_MEETING: true,
+          },
+          userDisplayHints: [
+            'ROSTER_IN_MEETING',
+            'LOCK_STATUS_UNLOCKED',
+            'LOCK_CONTROL_LOCK',
+            'LOWER_SOMEONE_ELSES_HAND',
+          ],
+        };
         locusInfo.updateMeetingInfo(newInfo, updateSelf);
         // since the info is the same but roles changed, it should call trigger the event
         checkMeetingInfoUpdatedCalledForRoles(true);