@webex/plugin-meetings 3.7.0-next.2 → 3.7.0-next.20

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

@@ -26,6 +26,7 @@ interface IInMeetingActions {
   canStartRecording?: boolean;
   canPauseRecording?: boolean;
   canResumeRecording?: boolean;
+  isPremiseRecordingEnabled?: boolean;
   canStopRecording?: boolean;
   canRaiseHand?: boolean;
   canLowerAllHands?: boolean;
@@ -93,6 +94,10 @@ interface IInMeetingActions {
   canShowStageView?: boolean;
   canEnableStageView?: boolean;
   canDisableStageView?: boolean;
+  isPracticeSessionOn?: boolean;
+  isPracticeSessionOff?: boolean;
+  canStartPracticeSession?: boolean;
+  canStopPracticeSession?: boolean;
 }
 
 /**
@@ -117,6 +122,8 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canResumeRecording = null;
 
+  isPremiseRecordingEnabled = null;
+
   canStopRecording = null;
 
   canSetMuteOnEntry = null;
@@ -266,6 +273,15 @@ export default class InMeetingActions implements IInMeetingActions {
   canEnableStageView = null;
 
   canDisableStageView = null;
+
+  isPracticeSessionOn = null;
+
+  isPracticeSessionOff = null;
+
+  canStartPracticeSession = null;
+
+  canStopPracticeSession = null;
+
   /**
    * Returns all meeting action options
    * @returns {Object}
@@ -288,6 +304,7 @@ export default class InMeetingActions implements IInMeetingActions {
     canPauseRecording: this.canPauseRecording,
     canResumeRecording: this.canResumeRecording,
     canStopRecording: this.canStopRecording,
+    isPremiseRecordingEnabled: this.isPremiseRecordingEnabled,
     canRaiseHand: this.canRaiseHand,
     canLowerAllHands: this.canLowerAllHands,
     canLowerSomeoneElsesHand: this.canLowerSomeoneElsesHand,
@@ -354,6 +371,10 @@ export default class InMeetingActions implements IInMeetingActions {
     canShowStageView: this.canShowStageView,
     canEnableStageView: this.canEnableStageView,
     canDisableStageView: this.canDisableStageView,
+    isPracticeSessionOn: this.isPracticeSessionOn,
+    isPracticeSessionOff: this.isPracticeSessionOff,
+    canStartPracticeSession: this.canStartPracticeSession,
+    canStopPracticeSession: this.canStopPracticeSession,
   });
 
   /**

package/src/meeting/index.ts

@@ -31,7 +31,6 @@ import {
 } from '@webex/internal-media-core';
 
 import {
-  getDevices,
   LocalStream,
   LocalCameraStream,
   LocalDisplayStream,
@@ -122,6 +121,8 @@ import {
   MEETING_PERMISSION_TOKEN_REFRESH_REASON,
   ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT,
   NAMED_MEDIA_GROUP_TYPE_AUDIO,
+  WEBINAR_ERROR_WEBCAST,
+  WEBINAR_ERROR_REGISTRATIONID,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -129,7 +130,7 @@ import {
   MeetingInfoV2PasswordError,
   MeetingInfoV2CaptchaError,
   MeetingInfoV2PolicyError,
-  MeetingInfoV2WebinarRegistrationError,
+  MeetingInfoV2JoinWebinarError,
 } from '../meeting-info/meeting-info-v2';
 import {CSI, ReceiveSlotManager} from '../multistream/receiveSlotManager';
 import SendSlotManager from '../multistream/sendSlotManager';
@@ -158,7 +159,7 @@ import ControlsOptionsManager from '../controls-options-manager';
 import PermissionError from '../common/errors/permission';
 import {LocusMediaRequest} from './locusMediaRequest';
 import {ConnectionStateHandler, ConnectionStateEvent} from './connectionStateHandler';
-import WebinarRegistrationError from '../common/errors/webinar-registration-error';
+import JoinWebinarError from '../common/errors/join-webinar-error';
 
 // default callback so we don't call an undefined function, but in practice it should never be used
 const DEFAULT_ICE_PHASE_CALLBACK = () => 'JOIN_MEETING_FINAL';
@@ -1767,15 +1768,20 @@ export default class Meeting extends StatelessWebexPlugin {
           this.meetingInfo = err.meetingInfo;
         }
         throw new PermissionError();
-      } else if (err instanceof MeetingInfoV2WebinarRegistrationError) {
+      } else if (err instanceof MeetingInfoV2JoinWebinarError) {
         this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_REGISTRATION;
+        if (WEBINAR_ERROR_WEBCAST.includes(err.wbxAppApiCode)) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NEED_JOIN_WITH_WEBCAST;
+        } else if (WEBINAR_ERROR_REGISTRATIONID.includes(err.wbxAppApiCode)) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_NEED_REGISTRATIONID;
+        }
         this.meetingInfoFailureCode = err.wbxAppApiCode;
 
         if (err.meetingInfo) {
           this.meetingInfo = err.meetingInfo;
         }
 
-        throw new WebinarRegistrationError();
+        throw new JoinWebinarError();
       } else if (err instanceof MeetingInfoV2PasswordError) {
         LoggerProxy.logger.info(
           // @ts-ignore
@@ -2660,6 +2666,7 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_PRACTICE_SESSION_STATUS_UPDATED, ({state}) => {
+      this.webinar.updatePracticeSessionStatus(state);
       Trigger.trigger(
         this,
         {file: 'meeting/index', function: 'setupLocusControlsListener'},
@@ -3254,6 +3261,9 @@ export default class Meeting extends StatelessWebexPlugin {
           options: {meetingId: this.id},
         });
       }
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.GUEST_ENTERED_LOBBY, {
+        correlation_id: this.correlationId,
+      });
       this.updateLLMConnection();
     });
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST, async (payload) => {
@@ -3277,6 +3287,9 @@ export default class Meeting extends StatelessWebexPlugin {
           name: 'client.lobby.exited',
           options: {meetingId: this.id},
         });
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.GUEST_EXITED_LOBBY, {
+          correlation_id: this.correlationId,
+        });
       }
       this.rtcMetrics?.sendNextMetrics();
       this.updateLLMConnection();
@@ -3510,6 +3523,7 @@ export default class Meeting extends StatelessWebexPlugin {
       emailAddress: string;
       email: string;
       phoneNumber: string;
+      roles: Array<string>;
     },
     alertIfActive = true
   ) {
@@ -3766,6 +3780,10 @@ export default class Meeting extends StatelessWebexPlugin {
             this.userDisplayHints,
             this.selfUserPolicies
           ),
+          isPremiseRecordingEnabled: RecordingUtil.isPremiseRecordingEnabled(
+            this.userDisplayHints,
+            this.selfUserPolicies
+          ),
           canRaiseHand: MeetingUtil.canUserRaiseHand(this.userDisplayHints),
           canLowerAllHands: MeetingUtil.canUserLowerAllHands(this.userDisplayHints),
           canLowerSomeoneElsesHand: MeetingUtil.canUserLowerSomeoneElsesHand(this.userDisplayHints),
@@ -3909,6 +3927,22 @@ export default class Meeting extends StatelessWebexPlugin {
             requiredHints: [DISPLAY_HINTS.DISABLE_STAGE_VIEW],
             displayHints: this.userDisplayHints,
           }),
+          isPracticeSessionOn: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.PRACTICE_SESSION_ON],
+            displayHints: this.userDisplayHints,
+          }),
+          isPracticeSessionOff: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.PRACTICE_SESSION_OFF],
+            displayHints: this.userDisplayHints,
+          }),
+          canStartPracticeSession: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHOW_PRACTICE_SESSION_START],
+            displayHints: this.userDisplayHints,
+          }),
+          canStopPracticeSession: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHOW_PRACTICE_SESSION_STOP],
+            displayHints: this.userDisplayHints,
+          }),
           canShareFile:
             (ControlsOptionsUtil.hasHints({
               requiredHints: [DISPLAY_HINTS.SHARE_FILE],
@@ -4071,10 +4105,11 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   private setLogUploadTimer() {
     // start with short timeouts and increase them later on so in case users have very long multi-hour meetings we don't get too fragmented logs
-    const LOG_UPLOAD_INTERVALS = [0.1, 1, 15, 15, 30, 30, 30, 60];
+    const LOG_UPLOAD_INTERVALS = [0.1, 15, 30, 60]; // in minutes
 
     const delay =
       1000 *
+      60 *
       // @ts-ignore - config coming from registerPlugin
       this.config.logUploadIntervalMultiplicationFactor *
       LOG_UPLOAD_INTERVALS[this.logUploadIntervalIndex];
@@ -5345,16 +5380,19 @@ export default class Meeting extends StatelessWebexPlugin {
       this.meetingFiniteStateMachine.reset();
     }
 
-    // @ts-ignore
-    this.webex.internal.newMetrics.submitClientEvent({
-      name: 'client.call.initiated',
-      payload: {
-        trigger: this.callStateForMetrics.joinTrigger || 'user-interaction',
-        isRoapCallEnabled: true,
-        pstnAudioType: options?.pstnAudioType,
-      },
-      options: {meetingId: this.id},
-    });
+    // send client.call.initiated unless told not to
+    if (options.sendCallInitiated !== false) {
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.call.initiated',
+        payload: {
+          trigger: this.callStateForMetrics.joinTrigger || 'user-interaction',
+          isRoapCallEnabled: true,
+          pstnAudioType: options?.pstnAudioType,
+        },
+        options: {meetingId: this.id},
+      });
+    }
 
     LoggerProxy.logger.log('Meeting:index#join --> Joining a meeting');
 
@@ -6739,32 +6777,6 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   }
 
-  /**
-   * Handles device logging
-   *
-   * @private
-   * @static
-   * @param {boolean} isAudioEnabled
-   * @param {boolean} isVideoEnabled
-   * @returns {Promise<void>}
-   */
-
-  private static async handleDeviceLogging(isAudioEnabled, isVideoEnabled): Promise<void> {
-    try {
-      let devices = [];
-      if (isVideoEnabled && isAudioEnabled) {
-        devices = await getDevices();
-      } else if (isVideoEnabled) {
-        devices = await getDevices(Media.DeviceKind.VIDEO_INPUT);
-      } else if (isAudioEnabled) {
-        devices = await getDevices(Media.DeviceKind.AUDIO_INPUT);
-      }
-      MeetingUtil.handleDeviceLogging(devices);
-    } catch {
-      // getDevices may fail if we don't have browser permissions, that's ok, we still can have a media connection
-    }
-  }
-
   /**
    * Returns a promise. This promise is created once the local sdp offer has been successfully created and is resolved
    * once the remote sdp answer has been received.
@@ -7267,12 +7279,6 @@ export default class Meeting extends StatelessWebexPlugin {
         turnServerInfo
       );
 
-      if (audioEnabled || videoEnabled) {
-        await Meeting.handleDeviceLogging(audioEnabled, videoEnabled);
-      } else {
-        LoggerProxy.logger.info(`${LOG_HEADER} device logging not required`);
-      }
-
       if (this.mediaProperties.hasLocalShareStream()) {
         await this.enqueueScreenShareFloorRequest();
       }

package/src/meeting/util.ts

@@ -496,15 +496,6 @@ const MeetingUtil = {
     }
   },
 
-  handleDeviceLogging: (devices = []) => {
-    const LOG_HEADER = 'MeetingUtil#handleDeviceLogging -->';
-
-    devices.forEach((device) => {
-      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${device.deviceId}`);
-      LoggerProxy.logger.log(LOG_HEADER, 'settings', JSON.stringify(device));
-    });
-  },
-
   endMeetingForAll: (meeting) => {
     if (meeting.meetingState === FULL_STATE.INACTIVE) {
       return Promise.reject(new MeetingNotActiveError());

package/src/meeting-info/meeting-info-v2.ts

@@ -18,7 +18,19 @@ const ADHOC_MEETING_DEFAULT_ERROR =
   'Failed starting the adhoc meeting, Please contact support team ';
 const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006];
 const POLICY_ERROR_CODES = [403049, 403104, 403103, 403048, 403102, 403101];
-const WEBINAR_REGISTRATION_ERROR_CODES = [403021, 403022, 403024];
+/**
+ * 403021 - Meeting registration is required
+ * 403022 - Meeting registration is still pending
+ * 403024 - Meeting registration have been rejected
+ * 403137 - Registration ID verified failure
+ * 423007 - Registration ID input too many time,please input captcha code
+ * 403026 - Need to join meeting via webcast
+ * 403037 - Meeting join required registration ID
+ * 403137 - Registration ID verified failure
+ *
+ */
+const JOIN_WEBINAR_ERROR_CODES = [403021, 403022, 403024, 403137, 423007, 403026, 403037, 403137];
+
 /**
  * Error to indicate that wbxappapi requires a password
  */
@@ -126,9 +138,9 @@ export class MeetingInfoV2CaptchaError extends Error {
 }
 
 /**
- * Error preventing join because of a webinar registration error
+ * Error preventing join because of a webinar have some error
  */
-export class MeetingInfoV2WebinarRegistrationError extends Error {
+export class MeetingInfoV2JoinWebinarError extends Error {
   meetingInfo: any;
   sdkMessage: any;
   wbxAppApiCode: any;
@@ -142,7 +154,7 @@ export class MeetingInfoV2WebinarRegistrationError extends Error {
    */
   constructor(wbxAppApiErrorCode?: number, meetingInfo?: object, message?: string) {
     super(`${message}, code=${wbxAppApiErrorCode}`);
-    this.name = 'MeetingInfoV2WebinarRegistrationError';
+    this.name = 'MeetingInfoV2JoinWebinarError';
     this.sdkMessage = message;
     this.stack = new Error().stack;
     this.wbxAppApiCode = wbxAppApiErrorCode;
@@ -204,21 +216,21 @@ export default class MeetingInfoV2 {
   };
 
   /**
-   * Raises a handleWebinarRegistrationError for webinar registration error codes
+   * Raises a handleJoinWebinarError for join webinar error codes
    * @param {any} err the error from the request
    * @returns {void}
    */
-  handleWebinarRegistrationError = (err) => {
+  handleJoinWebinarError = (err) => {
     if (!err.body) {
       return;
     }
 
-    if (WEBINAR_REGISTRATION_ERROR_CODES.includes(err.body?.code)) {
-      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.WEBINAR_REGISTRATION_ERROR, {
+    if (JOIN_WEBINAR_ERROR_CODES.includes(err.body?.code)) {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.JOIN_WEBINAR_ERROR, {
         code: err.body?.code,
       });
 
-      throw new MeetingInfoV2WebinarRegistrationError(
+      throw new MeetingInfoV2JoinWebinarError(
         err.body?.code,
         err.body?.data?.meetingInfo,
         err.body?.message
@@ -286,7 +298,7 @@ export default class MeetingInfoV2 {
       })
       .catch((err) => {
         this.handlePolicyError(err);
-        this.handleWebinarRegistrationError(err);
+        this.handleJoinWebinarError(err);
 
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADHOC_MEETING_FAILURE, {
           reason: err.message,
@@ -441,7 +453,7 @@ export default class MeetingInfoV2 {
 
         if (err?.statusCode === 403) {
           this.handlePolicyError(err);
-          this.handleWebinarRegistrationError(err);
+          this.handleJoinWebinarError(err);
 
           Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_PASSWORD_ERROR, {
             reason: err.message,

package/src/meetings/index.ts

@@ -56,7 +56,7 @@ import MeetingCollection from './collection';
 import {MEETING_KEY, INoiseReductionEffect, IVirtualBackgroundEffect} from './meetings.types';
 import MeetingsUtil from './util';
 import PermissionError from '../common/errors/permission';
-import WebinarRegistrationError from '../common/errors/webinar-registration-error';
+import JoinWebinarError from '../common/errors/join-webinar-error';
 import {SpaceIDDeprecatedError} from '../common/errors/webex-errors';
 import NoMeetingInfoError from '../common/errors/no-meeting-info';
 
@@ -155,6 +155,9 @@ export type BasicMeetingInformation = {
   };
   meetingInfo: any;
   sessionCorrelationId: string;
+  roles: string[];
+  getCurUserType: () => string | null;
+  callStateForMetrics: CallStateForMetrics;
 };
 
 /**
@@ -1143,6 +1146,9 @@ export default class Meetings extends WebexPlugin {
           sessionId: meeting.locusInfo?.fullState?.sessionId,
         },
       },
+      roles: meeting.roles,
+      callStateForMetrics: meeting.callStateForMetrics,
+      getCurUserType: meeting.getCurUserType,
     });
     this.meetingCollection.delete(meeting.id);
     Trigger.trigger(
@@ -1406,7 +1412,7 @@ export default class Meetings extends WebexPlugin {
         !(err instanceof CaptchaError) &&
         !(err instanceof PasswordError) &&
         !(err instanceof PermissionError) &&
-        !(err instanceof WebinarRegistrationError)
+        !(err instanceof JoinWebinarError)
       ) {
         LoggerProxy.logger.info(
           `Meetings:index#createMeeting --> Info Unable to fetch meeting info for ${destination}.`

package/src/members/util.ts

@@ -46,6 +46,7 @@ const MembersUtil = {
       {
         address:
           options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber,
+        ...(options.invitee.roles ? {roles: options.invitee.roles} : {}),
       },
     ],
     alertIfActive: options.alertIfActive,

package/src/metrics/constants.ts

@@ -70,7 +70,9 @@ const BEHAVIORAL_METRICS = {
   ROAP_HTTP_RESPONSE_MISSING: 'js_sdk_roap_http_response_missing',
   TURN_DISCOVERY_REQUIRES_OK: 'js_sdk_turn_discovery_requires_ok',
   REACHABILITY_COMPLETED: 'js_sdk_reachability_completed',
-  WEBINAR_REGISTRATION_ERROR: 'js_sdk_webinar_registration_error',
+  JOIN_WEBINAR_ERROR: 'js_sdk_join_webinar_error',
+  GUEST_ENTERED_LOBBY: 'js_sdk_guest_entered_lobby',
+  GUEST_EXITED_LOBBY: 'js_sdk_guest_exited_lobby',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/multistream/remoteMedia.ts

@@ -19,6 +19,14 @@ export type RemoteVideoResolution =
   | 'large' // 1080p or less
   | 'best'; // highest possible resolution
 
+const MAX_FS_VALUES = {
+  '90p': 60,
+  '180p': 240,
+  '360p': 920,
+  '720p': 3600,
+  '1080p': 8192,
+};
+
 /**
  * Converts pane size into h264 maxFs
  * @param {PaneSize} paneSize
@@ -29,28 +37,28 @@ export function getMaxFs(paneSize: RemoteVideoResolution): number {
 
   switch (paneSize) {
     case 'thumbnail':
-      maxFs = 60;
+      maxFs = MAX_FS_VALUES['90p'];
       break;
     case 'very small':
-      maxFs = 240;
+      maxFs = MAX_FS_VALUES['180p'];
       break;
     case 'small':
-      maxFs = 920;
+      maxFs = MAX_FS_VALUES['360p'];
       break;
     case 'medium':
-      maxFs = 3600;
+      maxFs = MAX_FS_VALUES['720p'];
       break;
     case 'large':
-      maxFs = 8192;
+      maxFs = MAX_FS_VALUES['1080p'];
       break;
     case 'best':
-      maxFs = 8192; // for now 'best' is 1080p, so same as 'large'
+      maxFs = MAX_FS_VALUES['1080p']; // for now 'best' is 1080p, so same as 'large'
       break;
     default:
       LoggerProxy.logger.warn(
         `RemoteMedia#getMaxFs --> unsupported paneSize: ${paneSize}, using "medium" instead`
       );
-      maxFs = 3600;
+      maxFs = MAX_FS_VALUES['720p'];
   }
 
   return maxFs;
@@ -117,16 +125,21 @@ export class RemoteMedia extends EventsScope {
       return;
     }
 
-    if (height < 135) {
-      fs = 60;
-    } else if (height < 270) {
-      fs = 240;
-    } else if (height < 540) {
-      fs = 920;
+    // we switch to the next resolution level when the height is 10% more than the current resolution height
+    // except for 1080p - we switch to it immediately when the height is more than 720p
+    const threshold = 1.1;
+    const getThresholdHeight = (h: number) => Math.round(h * threshold);
+
+    if (height < getThresholdHeight(90)) {
+      fs = MAX_FS_VALUES['90p'];
+    } else if (height < getThresholdHeight(180)) {
+      fs = MAX_FS_VALUES['180p'];
+    } else if (height < getThresholdHeight(360)) {
+      fs = MAX_FS_VALUES['360p'];
     } else if (height <= 720) {
-      fs = 3600;
+      fs = MAX_FS_VALUES['720p'];
     } else {
-      fs = 8192;
+      fs = MAX_FS_VALUES['1080p'];
     }
 
     this.receiveSlot?.setMaxFs(fs);

package/src/reachability/clusterReachability.ts

@@ -357,11 +357,14 @@ export class ClusterReachability extends EventsScope {
 
       this.startTimestamp = performance.now();
 
+      // Set up the state change listeners before triggering the ICE gathering
+      const gatherIceCandidatePromise = this.gatherIceCandidates();
+
       // not awaiting the next call on purpose, because we're not sending the offer anywhere and there won't be any answer
       // we just need to make this call to trigger the ICE gathering process
       this.pc.setLocalDescription(offer);
 
-      await this.gatherIceCandidates();
+      await gatherIceCandidatePromise;
     } catch (error) {
       LoggerProxy.logger.warn(`Reachability:ClusterReachability#start --> Error: `, error);
     }

package/src/recording-controller/enums.ts

@@ -1,8 +1,11 @@
-enum RecordingAction {
+export enum RecordingAction {
   Start = 'Start',
   Stop = 'Stop',
   Pause = 'Pause',
   Resume = 'Resume',
 }
 
-export default RecordingAction;
+export enum RecordingType {
+  Premise = 'premise',
+  Cloud = 'cloud',
+}

package/src/recording-controller/index.ts

@@ -1,9 +1,9 @@
 import PermissionError from '../common/errors/permission';
+import LoggerProxy from '../common/logs/logger-proxy';
 import {CONTROLS, HTTP_VERBS, SELF_POLICY} from '../constants';
 import MeetingRequest from '../meeting/request';
-import RecordingAction from './enums';
+import {RecordingAction, RecordingType} from './enums';
 import Util from './util';
-import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @description Recording manages the recording functionality of the meeting object, there should only be one instantation of recording per meeting
@@ -228,11 +228,12 @@ export default class RecordingController {
 
   /**
    * @param {RecordingAction} action
+   * @param {RecordingType} recordingType
    * @private
    * @memberof RecordingController
    * @returns {Promise}
    */
-  private recordingService(action: RecordingAction): Promise<any> {
+  private recordingService(action: RecordingAction, recordingType: RecordingType): Promise<any> {
     // @ts-ignore
     return this.request.request({
       body: {
@@ -242,6 +243,7 @@ export default class RecordingController {
         recording: {
           action: action.toLowerCase(),
         },
+        recordingType,
       },
       uri: `${this.serviceUrl}/loci/${this.locusId}/recording`,
       method: HTTP_VERBS.PUT,
@@ -276,14 +278,25 @@ export default class RecordingController {
    * @returns {Promise}
    */
   private recordingFacade(action: RecordingAction): Promise<any> {
+    const isPremiseRecordingEnabled = Util.isPremiseRecordingEnabled(
+      this.displayHints,
+      this.selfUserPolicies
+    );
     LoggerProxy.logger.log(
       `RecordingController:index#recordingFacade --> recording action [${action}]`
     );
 
+    let recordingType: RecordingType;
+    if (isPremiseRecordingEnabled) {
+      recordingType = RecordingType.Premise;
+    } else {
+      recordingType = RecordingType.Cloud;
+    }
+
     // assumes action is proper cased (i.e., Example)
     if (Util?.[`canUser${action}`](this.displayHints, this.selfUserPolicies)) {
       if (this.serviceUrl) {
-        return this.recordingService(action);
+        return this.recordingService(action, recordingType);
       }
 
       return this.recordingControls(action);

package/src/recording-controller/util.ts

@@ -1,33 +1,47 @@
 import {DISPLAY_HINTS, SELF_POLICY} from '../constants';
-import RecordingAction from './enums';
+import {RecordingAction} from './enums';
 import MeetingUtil from '../meeting/util';
 
 const canUserStart = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserPause = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserResume = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserStop = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP)) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+
+const isPremiseRecordingEnabled = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
@@ -70,6 +84,7 @@ export default {
   canUserPause,
   canUserResume,
   canUserStop,
+  isPremiseRecordingEnabled,
   deriveRecordingStates,
   extractLocusId,
 };