@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.200

package/src/meeting/{request.js → request.ts}

@@ -1,12 +1,15 @@
 import uuid from 'uuid';
 import {debounce} from 'lodash';
+// @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
+// @ts-ignore
 import {deviceType} from '@webex/common';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {
   ALERT,
   ALTERNATE_REDIRECT_TRUE,
+  BREAKOUTS,
   CALL,
   CONTROLS,
   DECLINE,
@@ -15,24 +18,70 @@ import {
   HTTP_VERBS,
   LEAVE,
   LOCI,
-  LOCUS,
-  MEDIA,
   PARTICIPANT,
   PROVISIONAL_TYPE_DIAL_IN,
   PROVISIONAL_TYPE_DIAL_OUT,
+  REACHABILITY,
   SEND_DTMF_ENDPOINT,
-  _SLIDES_
+  _SLIDES_,
+  ANNOTATION,
 } from '../constants';
+import {SendReactionOptions, ToggleReactionsOptions} from './request.type';
+import MeetingUtil from './util';
+import {AnnotationInfo} from '../annotation/annotation.types';
 
 /**
  * @class MeetingRequest
  */
 export default class MeetingRequest extends StatelessWebexPlugin {
-  constructor(attrs, options) {
-    super(attrs, options);
-    this.changeVideoLayoutDebounced = debounce(this.changeVideoLayout, 2000, {leading: true, trailing: true});
+  changeVideoLayoutDebounced: any;
+  meetingRef: WeakRef<any>;
+  locusDeltaRequest: (options: object) => Promise<any>;
+
+  /**
+   * Constructor
+   * @param {Object} attrs
+   * @param {Object} options
+   */
+  constructor(attrs: any, options: any) {
+    const {meeting, ...otherAttrs} = attrs;
+
+    super(otherAttrs, options);
+
+    this.locusDeltaRequest = MeetingUtil.generateLocusDeltaRequest(meeting);
+
+    this.changeVideoLayoutDebounced = debounce(this.changeVideoLayout, 2000, {
+      leading: true,
+      trailing: true,
+    });
   }
 
+  /**
+   * Returns joinCookie from boundedStorage if present.
+   * @returns {Object} joinCookie
+   */
+  private getJoinCookie = async () => {
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
+
+    if (joinCookieRaw) {
+      try {
+        const joinCookie = JSON.parse(joinCookieRaw);
+        if (joinCookie) {
+          return joinCookie;
+        }
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+        );
+      }
+    }
+
+    return null;
+  };
+
   /**
    * Make a network request to join a meeting
    * @param {Object} options
@@ -46,9 +95,33 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {boolean} options.pin
    * @param {boolean} options.moveToResource
    * @param {Object} options.roapMessage
+   * @param {boolean} options.breakoutsSupported
+   * @param {String} options.locale,
+   * @param {Array} options.deviceCapabilities
+   * @param {boolean} options.liveAnnotationSupported
    * @returns {Promise}
    */
-  async joinMeeting(options) {
+  async joinMeeting(options: {
+    sipUri: string;
+    deviceUrl: string;
+    locusUrl: string;
+    resourceId: string;
+    correlationId: string;
+    ensureConversation: boolean;
+    moderator: boolean;
+    pin: boolean;
+    moveToResource: boolean;
+    roapMessage: any;
+    asResourceOccupant: any;
+    inviteeAddress: any;
+    meetingNumber: any;
+    permissionToken: any;
+    preferTranscoding: any;
+    breakoutsSupported: boolean;
+    locale?: string;
+    deviceCapabilities?: Array<string>;
+    liveAnnotationSupported: boolean;
+  }) {
     const {
       asResourceOccupant,
       inviteeAddress,
@@ -63,36 +136,59 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       pin,
       moveToResource,
       roapMessage,
-      preferTranscoding
+      preferTranscoding,
+      breakoutsSupported,
+      locale,
+      deviceCapabilities = [],
+      liveAnnotationSupported,
     } = options;
 
-    LoggerProxy.logger.info(
-      'Meeting:request#joinMeeting --> Joining a meeting',
-      correlationId
-    );
+    LoggerProxy.logger.info('Meeting:request#joinMeeting --> Joining a meeting', correlationId);
 
     let url = '';
 
-    const body = {
+    const joinCookie = await this.getJoinCookie();
+
+    const body: any = {
       asResourceOccupant,
       device: {
         url: deviceUrl,
-        deviceType: this.config.meetings.deviceType
+        // @ts-ignore - config comes from registerPlugin
+        deviceType: this.config.meetings.deviceType,
       },
       usingResource: resourceId || null,
-      moveMediaToResource: resourceId && moveToResource || false,
+      moveMediaToResource: (resourceId && moveToResource) || false,
       correlationId,
       respOnlySdp: true,
       allowMultiDevice: true,
       ensureConversation: ensureConversation || false,
       supportsNativeLobby: 1,
       clientMediaPreferences: {
-        preferTranscoding: preferTranscoding ?? true
-      }
+        preferTranscoding: preferTranscoding ?? true,
+        joinCookie,
+      },
     };
 
+    if (breakoutsSupported) {
+      deviceCapabilities.push(BREAKOUTS.BREAKOUTS_SUPPORTED);
+    }
+    if (liveAnnotationSupported) {
+      deviceCapabilities.push(ANNOTATION.ANNOTATION_ON_SHARE_SUPPORTED);
+    }
+
+    if (locale) {
+      body.locale = locale;
+    }
+
+    // add deviceCapabilities prop
+    if (deviceCapabilities.length) {
+      body.deviceCapabilities = deviceCapabilities;
+    }
+    // @ts-ignore
     if (this.webex.meetings.clientRegion) {
+      // @ts-ignore
       body.device.countryCode = this.webex.meetings.clientRegion.countryCode;
+      // @ts-ignore
       body.device.regionCode = this.webex.meetings.clientRegion.regionCode;
     }
 
@@ -110,28 +206,29 @@ export default class MeetingRequest extends StatelessWebexPlugin {
 
     if (locusUrl) {
       url = `${locusUrl}/${PARTICIPANT}`;
-    }
-    else if (inviteeAddress || meetingNumber) {
+    } else if (inviteeAddress || meetingNumber) {
       try {
+        // @ts-ignore
         await this.webex.internal.services.waitForCatalog('postauth');
+        // @ts-ignore
         url = `${this.webex.internal.services.get('locus')}/${LOCI}/${CALL}`;
         body.invitee = {
-          address: inviteeAddress || `wbxmn:${meetingNumber}`
+          address: inviteeAddress || `wbxmn:${meetingNumber}`,
         };
-      }
-      catch (e) {
-        LoggerProxy.logger.error(`Meeting:request#joinMeeting Error Joining ${inviteeAddress || meetingNumber} --> ${e}`);
-        throw (e);
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `Meeting:request#joinMeeting Error Joining ${inviteeAddress || meetingNumber} --> ${e}`
+        );
+        throw e;
       }
     }
 
-
     // TODO: -- this will be resolved in SDK request
     url = url.concat(`?${ALTERNATE_REDIRECT_TRUE}`);
 
     if (resourceId === inviteeAddress) {
       body.callPreferences = {
-        requestedMedia: [_SLIDES_]
+        requestedMedia: [_SLIDES_],
       };
     }
 
@@ -139,10 +236,11 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       body.localMedias = roapMessage.localMedias;
     }
 
+    /// @ts-ignore
     return this.request({
       method: HTTP_VERBS.POST,
       uri: url,
-      body
+      body,
     });
   }
 
@@ -154,18 +252,22 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @returns {Promise}
    * @private
    */
-  refreshCaptcha({
+  private refreshCaptcha({
     captchaRefreshUrl,
-    captchaId
+    captchaId,
+  }: {
+    captchaRefreshUrl: string;
+    captchaId: string;
   }) {
     const body = {
-      captchaId
+      captchaId,
     };
 
+    // @ts-ignore
     return this.request({
       method: HTTP_VERBS.POST,
       uri: captchaRefreshUrl,
-      body
+      body,
     }).catch((err) => {
       LoggerProxy.logger.error(`Meeting:request#refreshCaptcha --> Error: ${err}`);
 
@@ -177,17 +279,22 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * Make a network request to add a dial in device
    * @param {Object} options
    * @param {String} options.correlationId
-   * @param {String} options.localUrl url for the meeting
+   * @param {String} options.locusUrl url for the meeting
    * @param {String} options.dialInUrl identifier for the to-be provisioned device
    * @param {String} options.clientUrl identifier for the web device
    * @returns {Promise}
    * @private
    */
-  dialIn({
+  private dialIn({
     locusUrl,
     dialInUrl,
     clientUrl,
-    correlationId
+    correlationId,
+  }: {
+    correlationId: string;
+    locusUrl: string;
+    dialInUrl: string;
+    clientUrl: string;
   }) {
     LoggerProxy.logger.info(
       'Meeting:request#dialIn --> Provisioning a dial in device',
@@ -200,17 +307,20 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         deviceType: deviceType.PROVISIONAL,
         provisionalType: PROVISIONAL_TYPE_DIAL_IN,
         url: dialInUrl,
-        clientUrl
+        clientUrl,
       },
-      correlationId
+      correlationId,
     };
 
-    return this.request({
+    // @ts-ignore
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.POST,
       uri,
-      body
+      body,
     }).catch((err) => {
-      LoggerProxy.logger.error(`Meeting:request#dialIn --> Error provisioning a dial in device, error ${err}`);
+      LoggerProxy.logger.error(
+        `Meeting:request#dialIn --> Error provisioning a dial in device, error ${err}`
+      );
 
       throw err;
     });
@@ -220,19 +330,25 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * Make a network request to add a dial out device
    * @param {Object} options
    * @param {String} options.correlationId
-   * @param {String} options.localUrl url for the meeting
+   * @param {String} options.locusUrl url for the meeting
    * @param {String} options.dialOutUrl identifier for the to-be provisioned device
    * @param {String} options.phoneNumber phone number to dial out to
    * @param {String} options.clientUrl identifier for the web device
    * @returns {Promise}
    * @private
    */
-  dialOut({
+  private dialOut({
     locusUrl,
     dialOutUrl,
     phoneNumber,
     clientUrl,
-    correlationId
+    correlationId,
+  }: {
+    correlationId: string;
+    locusUrl: string;
+    dialOutUrl: string;
+    phoneNumber: string;
+    clientUrl: string;
   }) {
     LoggerProxy.logger.info(
       'Meeting:request#dialOut --> Provisioning a dial out device',
@@ -246,72 +362,43 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         provisionalType: PROVISIONAL_TYPE_DIAL_OUT,
         url: dialOutUrl,
         dialoutAddress: phoneNumber,
-        clientUrl
+        clientUrl,
       },
-      correlationId
+      correlationId,
     };
 
-    return this.request({
+    // @ts-ignore
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.POST,
       uri,
-      body
+      body,
     }).catch((err) => {
-      LoggerProxy.logger.error(`Meeting:request#dialOut --> Error provisioning a dial out device, error ${err}`);
+      LoggerProxy.logger.error(
+        `Meeting:request#dialOut --> Error provisioning a dial out device, error ${err}`
+      );
 
       throw err;
     });
   }
 
   /**
-   * Syns the missed delta event
-   * @param {Object} options
-   * @param {boolen} options.desync flag to get partial or whole locus object
-   * @param {String} options.syncUrl sync url to get ht elatest locus delta
-   * @returns {Promise}
-   */
-  syncMeeting(options) {
-    /* eslint-disable no-else-return */
-    const {desync} = options;
-    let {syncUrl} = options;
-
-    /* istanbul ignore else */
-    if (desync) {
-      // check for existing URL parameters
-      syncUrl = syncUrl.concat(syncUrl.split('?')[1] ? '&' : '?').concat(`${LOCUS.SYNCDEBUG}=${desync}`);
-    }
-
-    return this.request({
-      method: HTTP_VERBS.GET,
-      uri: syncUrl
-    }) // TODO: Handle if delta sync failed . Get the full locus object
-      .catch((err) => {
-        LoggerProxy.logger.error(`Meeting:request#syncMeeting --> Error syncing meeting, error ${err}`);
-
-        return err;
-      });
-  }
-
-  /**
-   * Request to get the complete locus object
+   * Sends a requests to get the latest locus DTO, it might be a full Locus or a delta, depending on the url provided
    * @param {Object} options
-   * @param {boolen} options.desync flag to get partial or whole locus object
    * @param {String} options.locusUrl sync url to get ht elatest locus delta
    * @returns {Promise}
    */
-  getFullLocus(options) {
-    let {locusUrl} = options;
-    const {desync} = options;
-
-    if (locusUrl) {
-      if (desync) {
-        locusUrl += `?${LOCUS.SYNCDEBUG}=${desync}`;
-      }
+  getLocusDTO(options: {url: string}) {
+    const {url} = options;
 
+    if (url) {
+      // @ts-ignore
       return this.request({
         method: HTTP_VERBS.GET,
-        uri: locusUrl
+        uri: url,
       }).catch((err) => {
-        LoggerProxy.logger.error(`Meeting:request#getFullLocus --> Error getting full locus, error ${err}`);
+        LoggerProxy.logger.error(
+          `Meeting:request#getLocusDTO --> Error getting latest locus, error ${err}`
+        );
 
         return err;
       });
@@ -330,11 +417,16 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @returns {Promise}
    * @private
    */
-  disconnectPhoneAudio({
+  private disconnectPhoneAudio({
     locusUrl,
     phoneUrl,
     correlationId,
-    selfId
+    selfId,
+  }: {
+    locusUrl: string;
+    phoneUrl: string;
+    correlationId: string;
+    selfId: string;
   }) {
     LoggerProxy.logger.info(
       `Meeting:request#disconnectPhoneAudio --> request phone ${phoneUrl} to leave`,
@@ -345,15 +437,16 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     const body = {
       device: {
         deviceType: deviceType.PROVISIONAL,
-        url: phoneUrl
+        url: phoneUrl,
       },
-      correlationId
+      correlationId,
     };
 
-    return this.request({
+    // @ts-ignore
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.PUT,
       uri,
-      body
+      body,
     }).catch((err) => {
       LoggerProxy.logger.error(
         `Meeting:request#disconnectPhoneAudio --> Error when requesting phone ${phoneUrl} to leave, error ${err}`
@@ -378,27 +471,31 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     selfId,
     deviceUrl: url,
     resourceId,
-    correlationId
+    correlationId,
+  }: {
+    locusUrl: string;
+    selfId: string;
+    deviceUrl: string;
+    resourceId: string;
+    correlationId: string;
   }) {
-    LoggerProxy.logger.info(
-      'Meeting:request#leaveMeeting --> Leaving a meeting',
-      correlationId
-    );
+    LoggerProxy.logger.info('Meeting:request#leaveMeeting --> Leaving a meeting', correlationId);
 
     const uri = `${locusUrl}/${PARTICIPANT}/${selfId}/${LEAVE}`;
     const body = {
       device: {
+        // @ts-ignore
         deviceType: this.config.meetings.deviceType,
-        url
+        url,
       },
       usingResource: resourceId || null,
-      correlationId
+      correlationId,
     };
 
-    return this.request({
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.PUT,
       uri,
-      body
+      body,
     });
   }
 
@@ -410,59 +507,42 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {String} options.correlationId
    * @returns {Promise}
    */
-  acknowledgeMeeting(options) {
+  acknowledgeMeeting(options: {locusUrl: string; deviceUrl: string; correlationId: string}) {
     const uri = `${options.locusUrl}/${PARTICIPANT}/${ALERT}`;
     const body = {
       device: {
+        // @ts-ignore
         deviceType: this.config.meetings.deviceType,
-        url: options.deviceUrl
+        url: options.deviceUrl,
       },
-      correlationId: options.correlationId
+      correlationId: options.correlationId,
     };
 
-    return this.request({
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.PUT,
       uri,
-      body
+      body,
     });
   }
 
   /**
-   * Make a network request to acknowledge a meeting
+   * Makes a network request to lock the meeting
    * @param {Object} options
-   * @param {String} options.locusUrl
-   * @param {String} options.deviceUrl
-   * @param {String} options.id
+   * @param {Boolean} options.lock Whether it is locked or not
    * @returns {Promise}
    */
-  recordMeeting(options) {
-    const uri = `${options.locusUrl}/${CONTROLS}`;
-    const body = {
-      record: {
-        recording: options.recording,
-        paused: options.paused
-      }
-    };
-
-    return this.request({
-      method: HTTP_VERBS.PATCH,
-      uri,
-      body
-    });
-  }
-
   lockMeeting(options) {
     const uri = `${options.locusUrl}/${CONTROLS}`;
     const body = {
       lock: {
-        locked: options.lock
-      }
+        locked: options.lock,
+      },
     };
 
-    return this.request({
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.PATCH,
       uri,
-      body
+      body,
     });
   }
 
@@ -474,54 +554,21 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {String} options.reason
    * @returns {Promise}
    */
-  declineMeeting(options) {
+  declineMeeting(options: {locusUrl: string; deviceUrl: string; reason: string}) {
     const uri = `${options.locusUrl}/${PARTICIPANT}/${DECLINE}`;
     const body = {
       device: {
+        // @ts-ignore
         deviceType: this.config.meetings.deviceType,
-        url: options.deviceUrl
-      },
-      ...(options.reason && {reason: options.reason})
-    };
-
-    return this.request({
-      method: HTTP_VERBS.PUT,
-      uri,
-      body
-    });
-  }
-
-  /**
-   * Toggle remote audio and/or video
-   * @param {Object} options options for toggling
-   * @param {String} options.selfId Locus self id??
-   * @param {String} options.locusUrl Locus url
-   * @param {String} options.deviceUrl Url of a device
-   * @param {String} options.resourceId Populated if you are paired to a device
-   * @param {String} options.localMedias local sdps
-   * @param {Boolean} options.preferTranscoding false for multistream (Homer), true for transcoded media (Edonus)
-   * @returns {Promise}
-   */
-  remoteAudioVideoToggle(options) {
-    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.selfId}/${MEDIA}`;
-    const body = {
-      device: {
-        deviceType: this.config.meetings.deviceType,
-        url: options.deviceUrl
+        url: options.deviceUrl,
       },
-      usingResource: options.resourceId || null,
-      correlationId: options.correlationId,
-      respOnlySdp: true,
-      localMedias: options.localMedias,
-      clientMediaPreferences: {
-        preferTranscoding: options.preferTranscoding ?? true
-      }
+      ...(options.reason && {reason: options.reason}),
     };
 
-    return this.request({
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.PUT,
       uri,
-      body
+      body,
     });
   }
 
@@ -535,8 +582,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {String} options.uri floor grant uri
    * @returns {Promise}
    */
-  changeMeetingFloor(options) {
-    let floorReq = {disposition: options.disposition};
+  changeMeetingFloor(
+    options:
+      | {
+          disposition: string;
+          personUrl: string;
+          deviceUrl: string;
+          resourceId: string;
+          uri: string;
+          annotationInfo: AnnotationInfo;
+        }
+      | any
+  ) {
+    let floorReq: any = {disposition: options.disposition};
 
     /* istanbul ignore else */
     if (options.disposition === FLOOR_ACTION.GRANTED) {
@@ -545,31 +603,36 @@ export default class MeetingRequest extends StatelessWebexPlugin {
           url: options.personUrl,
           devices: [
             {
+              // @ts-ignore
               deviceType: this.config.meetings.deviceType,
-              url: options.deviceUrl
-            }
-          ]
+              url: options.deviceUrl,
+            },
+          ],
         },
         disposition: options.disposition,
         requester: {
-          url: options.personUrl
-        }
+          url: options.personUrl,
+        },
       };
     }
 
-    const body = {
+    const body: any = {
       floor: floorReq,
-      resourceUrl: options.resourceUrl
+      resourceUrl: options.resourceUrl,
     };
 
     if (options?.resourceToken) {
       body.resourceToken = options?.resourceToken;
     }
+    if (options?.annotationInfo) {
+      body.annotation = options?.annotationInfo;
+    }
 
+    // @ts-ignore
     return this.request({
       uri: options.uri,
       method: HTTP_VERBS.PUT,
-      body
+      body,
     });
   }
 
@@ -581,17 +644,18 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {String} options.tones a string of one or more DTMF tones to send
    * @returns {Promise}
    */
-  sendDTMF({locusUrl, deviceUrl, tones}) {
-    return this.request({
+  sendDTMF({locusUrl, deviceUrl, tones}: {locusUrl: string; deviceUrl: string; tones: string}) {
+    // @ts-ignore
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.POST,
       uri: `${locusUrl}/${SEND_DTMF_ENDPOINT}`,
       body: {
         deviceUrl,
         dtmf: {
           correlationId: uuid.v4(),
-          tones
-        }
-      }
+          tones,
+        },
+      },
     });
   }
 
@@ -614,39 +678,65 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     deviceUrl,
     layoutType,
     main,
-    content
+    content,
+  }: {
+    locusUrl: string;
+    deviceUrl: string;
+    layoutType: string;
+    main: {
+      width: number;
+      height: number;
+    };
+    content: {
+      width: number;
+      height: number;
+    };
   }) {
     // send main/content renderInfo only if both width and height are specified
     if (main && (!main.width || !main.height)) {
-      return Promise.reject(new Error(`Both width and height must be specified. One of them is missing for main: ${JSON.stringify(main)}`));
+      return Promise.reject(
+        new Error(
+          `Both width and height must be specified. One of them is missing for main: ${JSON.stringify(
+            main
+          )}`
+        )
+      );
     }
 
     if (content && (!content.width || !content.height)) {
-      return Promise.reject(new Error(`Both width and height must be specified. One of them is missing for content: ${JSON.stringify(content)}`));
+      return Promise.reject(
+        new Error(
+          `Both width and height must be specified. One of them is missing for content: ${JSON.stringify(
+            content
+          )}`
+        )
+      );
     }
 
-    const renderInfoMain = (main) ? {width: main.width, height: main.height} : undefined;
-    const renderInfoContent = (content) ? {width: content.width, height: content.height} : undefined;
-
-    const layoutParams = (renderInfoMain || renderInfoContent) ?
-      {
-        renderInfo:
-        {
-          main: renderInfoMain,
-          content: renderInfoContent
-        }
-      } : undefined;
-
-    return this.request({
+    const renderInfoMain = main ? {width: main.width, height: main.height} : undefined;
+    const renderInfoContent = content ? {width: content.width, height: content.height} : undefined;
+
+    const layoutParams =
+      renderInfoMain || renderInfoContent
+        ? {
+            renderInfo: {
+              main: renderInfoMain,
+              content: renderInfoContent,
+            },
+          }
+        : undefined;
+
+    // @ts-ignore
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.PUT,
       uri: `${locusUrl}/${CONTROLS}`,
       body: {
         layout: {
           deviceUrl,
           type: layoutType,
-          layoutParams
-        }
-      }
+          layoutParams,
+        },
+      },
     });
   }
 
@@ -656,14 +746,13 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {Url} options.locusUrl
    * @returns {Promise}
    */
-  endMeetingForAll({
-    locusUrl,
-  }) {
+  endMeetingForAll({locusUrl}: {locusUrl: string}) {
     const uri = `${locusUrl}/${END}`;
 
-    return this.request({
+    // @ts-ignore
+    return this.locusDeltaRequest({
       method: HTTP_VERBS.POST,
-      uri
+      uri,
     });
   }
 
@@ -673,12 +762,63 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {Url} options.keepAliveUrl
    * @returns {Promise}
    */
-  keepAlive({
-    keepAliveUrl,
-  }) {
+  keepAlive({keepAliveUrl}: {keepAliveUrl: string}) {
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: keepAliveUrl,
+    });
+  }
+
+  /**
+   * Make a network request to send a reaction.
+   * @param {Object} options
+   * @param {Url} options.reactionChannelUrl
+   * @param {Reaction} options.reaction
+   * @param {string} options.senderID
+   * @returns {Promise}
+   */
+  sendReaction({reactionChannelUrl, reaction, participantId}: SendReactionOptions) {
+    const uri = reactionChannelUrl;
+
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri,
+      body: {
+        sender: {participantId},
+        reaction,
+      },
+    });
+  }
+
+  /**
+   * Make a network request to enable or disable reactions.
+   * @param {boolean} options.enable - determines if we need to enable or disable.
+   * @param {locusUrl} options.locusUrl
+   * @returns {Promise}
+   */
+  toggleReactions({enable, locusUrl, requestingParticipantId}: ToggleReactionsOptions) {
+    const uri = `${locusUrl}/${CONTROLS}`;
+
+    // @ts-ignore
+    return this.locusDeltaRequest({
+      method: HTTP_VERBS.PUT,
+      uri,
+      body: {
+        reactions: {
+          enabled: enable,
+        },
+        requestingParticipantId,
+      },
+    });
+  }
+
+  getLocusStatusByUrl(locusUrl: string) {
+    // @ts-ignore
     return this.request({
       method: HTTP_VERBS.GET,
-      uri: keepAliveUrl
+      uri: locusUrl,
     });
   }
 }