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

package/src/meeting/index.ts

@@ -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,6 +1350,8 @@ export default class Meeting extends StatelessWebexPlugin {
         EVENT_TRIGGERS.MEETING_INFO_AVAILABLE
       );
 
+      this.updateMeetingActions();
+
       return Promise.resolve();
     } catch (err) {
       if (err instanceof MeetingInfoV2PolicyError) {
@@ -2393,6 +2397,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 +2466,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);
     });
   }
 
@@ -3234,6 +3030,233 @@ export default class Meeting extends StatelessWebexPlugin {
     MeetingUtil.parseInterpretationInfo(this, webexMeetingInfo);
   }
 
+  /**
+   * 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,
+          })) ||
+        // @ts-ignore
+        !this.config.experimental.enableUnifiedMeetings ||
+        this.isLocusCall(),
+    });
+    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,
+              }) ||
+                // @ts-ignore
+                !this.config.experimental.enableUnifiedMeetings)) ||
+            this.isLocusCall(),
+          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,
+              }) ||
+                // @ts-ignore
+                !this.config.experimental.enableUnifiedMeetings)) ||
+            this.isLocusCall(),
+          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,
+              }) ||
+                // @ts-ignore
+                !this.config.experimental.enableUnifiedMeetings)) ||
+            this.isLocusCall(),
+          canShareContent:
+            ControlsOptionsUtil.hasHints({
+              requiredHints: [DISPLAY_HINTS.SHARE_CONTENT],
+              displayHints: this.userDisplayHints,
+            }) || this.isLocusCall(),
+          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,7 +1406,7 @@ 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();
@@ -1417,6 +1416,21 @@ describe('plugin-meetings', () => {
 
         // since it was initially undefined, this should trigger the event
         checkMeetingInfoUpdatedCalled(true);
+        assert.deepEqual(mockMeeting, {
+          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'],
+        });
 
         const newInfo = cloneDeep(meetingInfo);
 
@@ -1426,12 +1440,44 @@ describe('plugin-meetings', () => {
         locusInfo.updateMeetingInfo(newInfo, self);
 
         checkMeetingInfoUpdatedCalled(true);
+        assert.deepEqual(mockMeeting, {
+          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'],
+        });
 
         // update it with the same info
         locusInfo.updateMeetingInfo(newInfo, self);
 
         // since the info is the same it should not call trigger the event
         checkMeetingInfoUpdatedCalled(false);
+        assert.deepEqual(mockMeeting, {
+          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'],
+        });
 
         // update it with the same info, but roles changed
         const updateSelf = cloneDeep(self);
@@ -1442,6 +1488,27 @@ describe('plugin-meetings', () => {
         locusInfo.updateMeetingInfo(newInfo, updateSelf);
         // since the info is the same but roles changed, it should call trigger the event
         checkMeetingInfoUpdatedCalledForRoles(true);
+        assert.deepEqual(mockMeeting, {
+          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',
+          ],
+        });
       });
 
       it('gets roles from self if available', () => {