@webex/plugin-meetings 1.151.5 → 1.152.1

package/src/common/errors/captcha-error.js

@@ -0,0 +1,21 @@
+import {ERROR_DICTIONARY} from '../../constants';
+
+/**
+ * Extended Error object to signify captcha related errors
+ */
+export default class CaptchaError extends Error {
+  /**
+  *
+  * @constructor
+  * @param {String} [message]
+  * @param {Object} [error]
+  */
+  constructor(message = ERROR_DICTIONARY.CAPTCHA.MESSAGE, error = null) {
+    super(message);
+    this.name = ERROR_DICTIONARY.CAPTCHA.NAME;
+    this.sdkMessage = ERROR_DICTIONARY.CAPTCHA.MESSAGE;
+    this.error = error;
+    this.stack = error ? error.stack : (new Error()).stack;
+    this.code = ERROR_DICTIONARY.CAPTCHA.CODE;
+  }
+}

package/src/common/errors/password-error.js

@@ -0,0 +1,21 @@
+import {ERROR_DICTIONARY} from '../../constants';
+
+/**
+ * Extended Error object to signify password related errors
+ */
+export default class PasswordError extends Error {
+  /**
+  *
+  * @constructor
+  * @param {String} [message]
+  * @param {Object} [error]
+  */
+  constructor(message = ERROR_DICTIONARY.PASSWORD.MESSAGE, error = null) {
+    super(message);
+    this.name = ERROR_DICTIONARY.PASSWORD.NAME;
+    this.sdkMessage = ERROR_DICTIONARY.PASSWORD.MESSAGE;
+    this.error = error;
+    this.stack = error ? error.stack : (new Error()).stack;
+    this.code = ERROR_DICTIONARY.PASSWORD.CODE;
+  }
+}

package/src/config.js

@@ -76,7 +76,8 @@ export default {
       // please note, these are the maximum bandwidth values
       // the server supports, minimums have to be tested
       audio: 64000,
-      video: 4000000
+      video: 4000000,
+      startBitrate: 2000
     },
     screenFrameRate: 10,
     videoShareFrameRate: 30,

package/src/constants.js

@@ -559,6 +559,16 @@ export const ERROR_DICTIONARY = {
     NAME: 'StatsError',
     MESSAGE: 'An error occurred with getStats, stats may not continue for this data stream.',
     CODE: 6
+  },
+  PASSWORD: {
+    NAME: 'PasswordError',
+    MESSAGE: 'Password is required, please use verifyPassword()',
+    CODE: 7
+  },
+  CAPTCHA: {
+    NAME: 'CaptchaError',
+    MESSAGE: 'Captcha is required.',
+    CODE: 8
   }
 };
 
@@ -1251,3 +1261,17 @@ export const PSTN_STATUS = {
   SUCCESS: 'SUCCESS', // happens after the transfer (TRANSFERRING) is successful
   UNKNOWN: '' // placeholder if we haven't been told what the status is
 };
+
+export const PASSWORD_STATUS = {
+  NOT_REQUIRED: 'NOT_REQUIRED', // password is not required to join the meeting
+  REQUIRED: 'REQUIRED', // client needs to provide the password by calling verifyPassword() before calling join()
+  UNKNOWN: 'UNKNOWN', // we are waiting for information from the backend if password is required or not
+  VERIFIED: 'VERIFIED' // client has already provided the password and it has been verified, client can proceed to call join()
+};
+
+export const MEETING_INFO_FAILURE_REASON = {
+  NONE: 'NONE', // meeting info was retrieved succesfully
+  WRONG_PASSWORD: 'WRONG_PASSWORD', // meeting requires password and no password or wrong one was provided
+  WRONG_CAPTCHA: 'WRONG_CAPTCHA', // wbxappapi requires a captcha code or a wrong captcha code was provided
+  OTHER: 'OTHER' // any other error (network, etc)
+};

package/src/meeting/index.js

@@ -29,12 +29,15 @@ import WebRTCStats from '../stats/index';
 import StatsMetrics from '../stats/metrics';
 import StatsUtil from '../stats/util';
 import Transcription from '../transcription';
+import PasswordError from '../common/errors/password-error';
+import CaptchaError from '../common/errors/captcha-error';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
 import {
   _CALL_,
   _INCOMING_,
   _JOIN_,
+  _SIP_URI_,
   AUDIO,
   CONNECTION_STATE,
   CONTENT,
@@ -47,6 +50,7 @@ import {
   LAYOUT_TYPES,
   LIVE,
   LOCUSINFO,
+  MEETING_INFO_FAILURE_REASON,
   MEETING_REMOVED_REASON,
   MEETING_STATE_MACHINE,
   MEETING_STATE,
@@ -57,6 +61,7 @@ import {
   NETWORK_STATUS,
   ONLINE,
   OFFLINE,
+  PASSWORD_STATUS,
   PC_BAIL_TIMEOUT,
   PSTN_STATUS,
   QUALITY_LEVELS,
@@ -73,6 +78,7 @@ import {
 } from '../constants';
 import ParameterError from '../common/errors/parameter';
 import MediaError from '../common/errors/media';
+import {MeetingInfoV2PasswordError, MeetingInfoV2CaptchaError} from '../meeting-info/meeting-info-v2';
 import MQAProcessor from '../metrics/mqa-processor';
 import BrowserDetection from '../common/browser-detection';
 import RoapCollection from '../roap/collection';
@@ -846,8 +852,173 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.transcription = undefined;
 
+    /**
+     * Password status. If it's PASSWORD_STATUS.REQUIRED then verifyPassword() needs to be called
+     * with the correct password before calling join()
+     * @instance
+     * @type {PASSWORD_STATUS}
+     * @public
+     * @memberof Meeting
+     */
+    this.passwordStatus = PASSWORD_STATUS.UNKNOWN;
+
+    /**
+     * Information about required captcha. If null, then no captcha is required. status. If it's PASSWORD_STATUS.REQUIRED then verifyPassword() needs to be called
+     * with the correct password before calling join()
+     * @instance
+     * @type {Object}
+     * @property {string} captchaId captcha id
+     * @property {string} verificationImageURL Url of the captcha image
+     * @property {string} verificationAudioURL Url of the captcha audio file
+     * @property {string} refreshURL Url used for refreshing the captcha (don't use it directly, call refreshCaptcha() instead)
+     * @public
+     * @memberof Meeting
+     */
+    this.requiredCaptcha = null;
+
+    /**
+     * Indicates the reason for last failure to obtain meeting.meetingInfo. MEETING_INFO_FAILURE_REASON.NONE if meeting info was
+     * retrieved successfully
+     * @instance
+     * @type {MEETING_INFO_FAILURE_REASON}
+     * @private
+     * @memberof Meeting
+     */
+    this.meetingInfoFailureReason = undefined;
+
     this.setUpLocusInfoListeners();
     this.locusInfo.init(attrs.locus ? attrs.locus : {});
+    this.isCreated = true;
+  }
+
+  /**
+   * Fetches meeting information.
+   * @param {Object} options
+   * @param {String} options.destination
+   * @param {String} options.type
+   * @private
+   * @memberof Meeting
+   * @returns {Promise}
+   */
+  async fetchMeetingInfo({
+    destination, type, password = null, captchaCode = null
+  }) {
+    if (captchaCode && !this.requiredCaptcha) {
+      return Promise.reject(new Error('fetchMeetingInfo() called with captchaCode when captcha was not required'));
+    }
+    if (password && (this.passwordStatus !== PASSWORD_STATUS.REQUIRED && this.passwordStatus !== PASSWORD_STATUS.UNKNOWN)) {
+      return Promise.reject(new Error('fetchMeetingInfo() called with password when password was not required'));
+    }
+
+    try {
+      const captchaInfo = captchaCode ? {code: captchaCode, id: this.requiredCaptcha.captchaId} : null;
+
+      const info = await this.attrs.meetingInfoProvider.fetchMeetingInfo(destination, type, password, captchaInfo);
+
+      this.parseMeetingInfo(info);
+      this.meetingInfo = info ? info.body : null;
+      this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NONE;
+      this.requiredCaptcha = null;
+      if ((this.passwordStatus === PASSWORD_STATUS.REQUIRED) || (this.passwordStatus === PASSWORD_STATUS.VERIFIED)) {
+        this.passwordStatus = PASSWORD_STATUS.VERIFIED;
+      }
+      else {
+        this.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
+      }
+
+      return Promise.resolve();
+    }
+    catch (err) {
+      if (err instanceof MeetingInfoV2PasswordError) {
+        LoggerProxy.logger.info(`Meeting:index#fetchMeetingInfo --> Info Unable to fetch meeting info for ${destination} - password required (code=${err?.body?.code}).`);
+
+        // when wbxappapi requires password it still populates partial meeting info in the response
+        if (err.meetingInfo) {
+          this.meetingInfo = err.meetingInfo;
+          this.meetingNumber = err.meetingInfo.meetingNumber;
+        }
+
+        this.passwordStatus = PASSWORD_STATUS.REQUIRED;
+        this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+        if (this.requiredCaptcha) {
+          // this is a workaround for captcha service bug, see WEBEX-224862
+          await this.refreshCaptcha();
+        }
+
+        throw (new PasswordError());
+      }
+      else if (err instanceof MeetingInfoV2CaptchaError) {
+        LoggerProxy.logger.info(`Meeting:index#fetchMeetingInfo --> Info Unable to fetch meeting info for ${destination} - captcha required (code=${err?.body?.code}).`);
+
+        this.meetingInfoFailureReason = (this.requiredCaptcha) ?
+          MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA :
+          MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+
+        if (err.isPasswordRequired) {
+          this.passwordStatus = PASSWORD_STATUS.REQUIRED;
+        }
+
+        this.requiredCaptcha = err.captchaInfo;
+        throw (new CaptchaError());
+      }
+      else {
+        this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.OTHER;
+        throw (err);
+      }
+    }
+  }
+
+  /**
+   * Checks if the supplied password/host key is correct. It returns a promise with information whether the
+   * password and captcha code were correct or not.
+   * @param {String} password - this can be either a password or a host key, can be undefined if only captcha was required
+   * @param {String} captchaCode - can be undefined if captcha was not required by the server
+   * @public
+   * @memberof Meeting
+   * @returns {Promise<{isPasswordValid: boolean, requiredCaptcha: boolean, failureReason: MEETING_INFO_FAILURE_REASON}>}
+   */
+  verifyPassword(password, captchaCode) {
+    return this.fetchMeetingInfo({
+      destination: this.sipUri, type: _SIP_URI_, password, captchaCode
+    })
+      .then(() => ({isPasswordValid: true, requiredCaptcha: null, failureReason: MEETING_INFO_FAILURE_REASON.NONE}))
+      .catch((error) => {
+        if (error instanceof PasswordError || error instanceof CaptchaError) {
+          return {
+            isPasswordValid: this.passwordStatus === PASSWORD_STATUS.VERIFIED,
+            requiredCaptcha: this.requiredCaptcha,
+            failureReason: this.meetingInfoFailureReason
+          };
+        }
+        throw (error);
+      });
+  }
+
+  /**
+   * Refreshes the captcha. As a result the meeting will have new captcha id, image and audio.
+   * If the refresh operation fails, meeting remains with the old captcha properties.
+   * @public
+   * @memberof Meeting
+   * @returns {Promise}
+   */
+  refreshCaptcha() {
+    if (!this.requiredCaptcha) {
+      return Promise.reject(new Error('There is no captcha to refresh'));
+    }
+
+    // in order to get fully populated uris for captcha audio and image in response to refresh captcha request
+    // we have to pass the wbxappapi hostname as the siteFullName parameter
+    const {hostname} = new URL(this.requiredCaptcha.refreshURL);
+
+    return this.meetingRequest.refreshCaptcha({
+      captchaRefreshUrl: `${this.requiredCaptcha.refreshURL}&siteFullName=${hostname}`,
+      captchaId: this.requiredCaptcha.captchaId
+    })
+      .then((response) => {
+        this.requiredCaptcha.captchaId = response.body.captchaID;
+        this.requiredCaptcha.verificationImageURL = response.body.verificationImageURL;
+        this.requiredCaptcha.verificationAudioURL = response.body.verificationAudioURL;
+      });
   }
 
   /**
@@ -3325,11 +3496,15 @@ export default class Meeting extends StatelessWebexPlugin {
       joinSuccess = resolve;
     });
 
-
-    LoggerProxy.logger.log(`Meeting:index#join --> Generating a new correlation id for meeting ${this.id}`);
-    LoggerProxy.logger.log(`Meeting:index#join --> Previous correlation id ${this.correlationId}`);
-    this.setCorrelationId(uuid.v4());
-    LoggerProxy.logger.log(`Meeting:index#join --> New correlation id ${this.correlationId}`);
+    if (this.isCreated) {
+      this.isCreated = false;
+    }
+    else {
+      LoggerProxy.logger.log(`Meeting:index#join --> Generating a new correlation id for meeting ${this.id}`);
+      LoggerProxy.logger.log(`Meeting:index#join --> Previous correlation id ${this.correlationId}`);
+      this.setCorrelationId(uuid.v4());
+      LoggerProxy.logger.log(`Meeting:index#join --> New correlation id ${this.correlationId}`);
+    }
 
     if (options.rejoin) {
       this.meetingFiniteStateMachine.reset();

package/src/meeting/request.js

@@ -140,6 +140,33 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     });
   }
 
+  /**
+   * Send a request to refresh the captcha
+   * @param {Object} options
+   * @param {String} options.captchaRefreshUrl
+   * @param {String} options.captchaId
+   * @returns {Promise}
+   * @private
+   */
+  refreshCaptcha({
+    captchaRefreshUrl,
+    captchaId
+  }) {
+    const body = {
+      captchaId
+    };
+
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri: captchaRefreshUrl,
+      body
+    }).catch((err) => {
+      LoggerProxy.logger.error(`Meeting:request#refreshCaptcha --> Error: ${err}`);
+
+      throw err;
+    });
+  }
+
   /**
    * Make a network request to add a dial in device
    * @param {Object} options

package/src/meeting/util.js

@@ -7,19 +7,23 @@ import {eventType, trigger, mediaType} from '../metrics/config';
 import Media from '../media';
 import LoggerProxy from '../common/logs/logger-proxy';
 import WebRTCStats from '../stats/index';
-import {INTENT_TO_JOIN,
+import {
+  INTENT_TO_JOIN,
   _LEFT_,
   _IDLE_,
   _JOINED_,
   STATS,
-  EVENT_TRIGGERS
-  , FULL_STATE} from '../constants';
+  EVENT_TRIGGERS,
+  FULL_STATE,
+  PASSWORD_STATUS
+} from '../constants';
 import Trigger from '../common/events/trigger-proxy';
 import IntentToJoinError from '../common/errors/intent-to-join';
 import JoinMeetingError from '../common/errors/join-meeting';
 import ParameterError from '../common/errors/parameter';
 import PermissionError from '../common/errors/permission';
-
+import PasswordError from '../common/errors/password-error';
+import CaptchaError from '../common/errors/captcha-error';
 
 const MeetingUtil = {};
 
@@ -240,6 +244,13 @@ MeetingUtil.isMediaEstablished = (currentMediaStatus) =>
 MeetingUtil.joinMeetingOptions = (meeting, options = {}) => {
   meeting.resourceId = meeting.resourceId || options.resourceId;
 
+  if (meeting.requiredCaptcha) {
+    return Promise.reject(new CaptchaError());
+  }
+  if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
+    return Promise.reject(new PasswordError());
+  }
+
   if (options.pin) {
     Metrics.postEvent({
       event: eventType.PIN_COLLECTED,

package/src/meeting-info/index.js

@@ -4,7 +4,8 @@
 
 import {
   _MEETING_LINK_,
-  _SIP_URI_
+  _SIP_URI_,
+  _PERSONAL_ROOM_
 } from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -108,6 +109,10 @@ export default class MeetingInfo {
    * @memberof MeetingInfo
    */
   fetchMeetingInfo(destination, type = null) {
+    if (type === _PERSONAL_ROOM_ && !destination) {
+      destination = this.webex.internal.device.userId;
+    }
+
     return this.fetchInfoOptions(
       MeetingInfoUtil.extractDestination(destination, type),
       type

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

@@ -3,6 +3,52 @@ import {HTTP_VERBS} from '../constants';
 
 import MeetingInfoUtil from './utilv2';
 
+const PASSWORD_ERROR_DEFAULT_MESSAGE = 'Password required. Call fetchMeetingInfo() with password argument';
+const CAPTCHA_ERROR_DEFAULT_MESSAGE = 'Captcha required. Call fetchMeetingInfo() with captchaInfo argument';
+
+/**
+ * Error to indicate that wbxappapi requires a password
+ */
+export class MeetingInfoV2PasswordError extends Error {
+  /**
+    *
+    * @constructor
+    * @param {Number} [wbxAppApiErrorCode]
+    * @param {Object} [meetingInfo]
+    * @param {String} [message]
+    */
+  constructor(wbxAppApiErrorCode, meetingInfo, message = PASSWORD_ERROR_DEFAULT_MESSAGE) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2PasswordError';
+    this.sdkMessage = message;
+    this.stack = (new Error()).stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.meetingInfo = meetingInfo;
+  }
+}
+
+/**
+   * Error to indicate that wbxappapi requires a captcha
+   */
+export class MeetingInfoV2CaptchaError extends Error {
+  /**
+    *
+    * @constructor
+    * @param {Number} [wbxAppApiErrorCode]
+    * @param {Object} [captchaInfo]
+    * @param {String} [message]
+    */
+  constructor(wbxAppApiErrorCode, captchaInfo, message = CAPTCHA_ERROR_DEFAULT_MESSAGE) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2PasswordError';
+    this.sdkMessage = message;
+    this.stack = (new Error()).stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.isPasswordRequired = wbxAppApiErrorCode === 423005;
+    this.captchaInfo = captchaInfo;
+  }
+}
+
 /**
    * @class MeetingInfo
    */
@@ -35,24 +81,42 @@ export default class MeetingInfoV2 {
      * Fetches meeting info from the server
      * @param {String} destination one of many different types of destinations to look up info for
      * @param {String} [type] to match up with the destination value
+     * @param {String} password
+     * @param {Object} captchaInfo
+     * @param {String} captchaInfo.code
+     * @param {String} captchaInfo.id
      * @returns {Promise} returns a meeting info object
      * @public
      * @memberof MeetingInfo
      */
-  async fetchMeetingInfo(destination, type = null) {
+  async fetchMeetingInfo(destination, type = null, password = null, captchaInfo = null) {
     const destinationType = await MeetingInfoUtil.getDestinationType({
       destination,
       type,
       webex: this.webex
     });
-    const body = await MeetingInfoUtil.getRequestBody(destinationType);
+    const body = await MeetingInfoUtil.getRequestBody({...destinationType, password, captchaInfo});
 
     return this.webex.request({
       method: HTTP_VERBS.POST,
       service: 'webex-appapi-service',
       resource: 'meetingInfo',
       body
-    });
+    })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          throw new MeetingInfoV2PasswordError(err.body?.code, err.body?.data?.meetingInfo);
+        }
+        if (err?.statusCode === 423) {
+          throw new MeetingInfoV2CaptchaError(err.body?.code, {
+            captchaId: err.body.captchaID,
+            verificationImageURL: err.body.verificationImageURL,
+            verificationAudioURL: err.body.verificationAudioURL,
+            refreshURL: err.body.refreshURL
+          });
+        }
+        throw err;
+      });
   }
 }
 

package/src/meeting-info/utilv2.js

@@ -212,7 +212,9 @@ MeetingInfoUtil.getDestinationType = async (from) => {
  * @returns {Object} returns an object with {resource, method}
  */
 MeetingInfoUtil.getRequestBody = (options) => {
-  const {type, destination} = options;
+  const {
+    type, destination, password, captchaInfo
+  } = options;
   const body = {
     supportHostKey: true
   };
@@ -250,6 +252,15 @@ MeetingInfoUtil.getRequestBody = (options) => {
     default:
   }
 
+  if (password) {
+    body.password = password;
+  }
+
+  if (captchaInfo) {
+    body.captchaID = captchaInfo.id;
+    body.captchaVerifyCode = captchaInfo.code;
+  }
+
   return body;
 };
 

package/src/meetings/index.js

@@ -48,6 +48,8 @@ import Reachability from '../reachability';
 import Request from '../meetings/request';
 import StatsAnalyzer from '../analyzer/analyzer';
 import StatsCalculator from '../analyzer/calculator';
+import PasswordError from '../common/errors/password-error';
+import CaptchaError from '../common/errors/captcha-error';
 
 import MeetingCollection from './collection';
 import MeetingsUtil from './util';
@@ -141,7 +143,7 @@ export default class Meetings extends WebexPlugin {
        * @public
        * @memberof Meetings
        */
-      this.personalMeetingRoom = new PersonalMeetingRoom({}, {parent: this.webex});
+      this.personalMeetingRoom = null;
       /**
        * The Reachability object to interact with server, starts as null until {@link Meeting#setReachability} is called
        * starts as null
@@ -382,6 +384,7 @@ export default class Meetings extends WebexPlugin {
        * @memberof Meetings
        */
         this.meetingInfo = this.config.experimental.enableUnifiedMeetings ? new MeetingInfoV2(this.webex) : new MeetingInfo(this.webex);
+        this.personalMeetingRoom = new PersonalMeetingRoom({meetingInfo: this.meetingInfo}, {parent: this.webex});
 
         Trigger.trigger(
           this,
@@ -715,7 +718,8 @@ export default class Meetings extends WebexPlugin {
           deviceUrl: this.webex.internal.device.url,
           orgId: this.webex.internal.device.orgId,
           roapSeq: 0,
-          locus: type === _LOCUS_ID_ ? destination : null // pass the locus object if present
+          locus: type === _LOCUS_ID_ ? destination : null, // pass the locus object if present
+          meetingInfoProvider: this.meetingInfo
         },
         {
           parent: this.webex
@@ -725,15 +729,14 @@ export default class Meetings extends WebexPlugin {
       this.meetingCollection.set(meeting);
 
       try {
-        const info = await this.meetingInfo.fetchMeetingInfo(destination, type);
-
-        meeting.parseMeetingInfo(info);
-        meeting.meetingInfo = info ? info.body : null;
+        await meeting.fetchMeetingInfo({destination, type});
       }
       catch (err) {
-        // if there is no meeting info we assume its a 1:1 call or wireless share
-        LoggerProxy.logger.info(`Meetings:index#createMeeting --> Info Unable to fetch meeting info for ${destination}.`);
-        LoggerProxy.logger.info('Meetings:index#createMeeting --> Info assuming this destination is a 1:1 or wireless share');
+        if (!(err instanceof CaptchaError) && !(err instanceof PasswordError)) {
+          // if there is no meeting info we assume its a 1:1 call or wireless share
+          LoggerProxy.logger.info(`Meetings:index#createMeeting --> Info Unable to fetch meeting info for ${destination}.`);
+          LoggerProxy.logger.info('Meetings:index#createMeeting --> Info assuming this destination is a 1:1 or wireless share');
+        }
         LoggerProxy.logger.debug(`Meetings:index#createMeeting --> Debug ${err} fetching /meetingInfo for creation.`);
         // We need to save this info for future reference
         meeting.destination = destination;

package/src/peer-connection-manager/index.js

@@ -79,11 +79,20 @@ const setMaxFs = (sdp, level = QUALITY_LEVELS.HIGH) => {
   let replaceSdp = sdp;
   const maxFsLine = `${SDP.MAX_FS}${MAX_FRAMESIZES[level]}`;
 
-  replaceSdp = replaceSdp.replace(/(\na=fmtp:(\d+).*level-asymmetry-allowed=1.*)/gi, `$1;${maxFsLine}`);
+  replaceSdp = replaceSdp.replace(/(\na=fmtp:(\d+).*profile-level-id=.*)/gi, `$1;${maxFsLine}`);
 
   return replaceSdp;
 };
 
+
+const setStartBitrateOnRemoteSdp = (sdp) => {
+  if (StaticConfig.meetings.bandwidth.startBitrate) {
+    sdp = sdp.replace(/(\na=fmtp:(\d+).*profile-level-id=.*)/gi, `$1;x-google-start-bitrate=${StaticConfig.meetings.bandwidth.startBitrate}`);
+  }
+
+  return sdp;
+};
+
 /**
  * checks that sdp has h264 codec in it
  * @param {String} sdp
@@ -295,7 +304,7 @@ pc.setRemoteSessionDetails = (
   meetingId,
 ) => {
   LoggerProxy.logger.log(`PeerConnectionManager:index#setRemoteSessionDetails --> Setting the remote description type: ${typeStr}State: ${peerConnection.signalingState}`);
-  const sdp = remoteSdp;
+  let sdp = remoteSdp;
 
   // making sure that the remoteDescription is only set when there is a answer for offer
   // or there is a offer from the server
@@ -312,6 +321,8 @@ pc.setRemoteSessionDetails = (
     });
   }
   if (peerConnection.signalingState === SDP.HAVE_LOCAL_OFFER || (peerConnection.signalingState === SDP.STABLE && typeStr === SDP.OFFER)) {
+    sdp = setStartBitrateOnRemoteSdp(sdp);
+
     return peerConnection.setRemoteDescription(
       new window.RTCSessionDescription({
         type: typeStr,

package/src/personal-meeting-room/index.js

@@ -1,7 +1,6 @@
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import {MEETINGS, _PERSONAL_ROOM_} from '../constants';
-import MeetingInfoRequest from '../meeting-info/request';
 import ParameterError from '../common/errors/parameter';
 
 import PersonalMeetingRoomRequest from './request';
@@ -63,11 +62,11 @@ export default class PersonalMeetingRoom extends StatelessWebexPlugin {
     /**
      * The meeting info request server interface
      * @instance
-     * @type {MeetingInfoRequest}
+     * @type {MeetingInfo}
      * @private
      * @memberof PersonalMeetingRoom
     */
-    this.meetingInfoRequest = new MeetingInfoRequest(options.parent);
+    this.meetingInfo = attrs.meetingInfo;
     /**
      * The pmr server request interface
      * @instance
@@ -131,11 +130,11 @@ export default class PersonalMeetingRoom extends StatelessWebexPlugin {
    */
   get() {
     const options = {
-      type: _PERSONAL_ROOM_,
-      destination: this.webex.internal.device.userId
+      type: _PERSONAL_ROOM_
+
     };
 
-    return this.meetingInfoRequest.fetchMeetingInfo(options).then((pmr) => {
+    return this.meetingInfo.fetchMeetingInfo(options).then((pmr) => {
       if (pmr && pmr.body && pmr.body.isPmr) {
         this.set(pmr.body);
       }