@webex/plugin-meetings 1.151.6 → 1.153.0

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/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';
@@ -395,6 +397,23 @@ export default class Meetings extends WebexPlugin {
       });
     }
 
+    /**
+     * API to toggle unified meetings
+     * @param {Boolean} changeState
+     * @private
+     * @memberof Meetings
+     * @returns {undefined}
+    */
+    _toggleUnifiedMeetings(changeState) {
+      if (typeof changeState !== 'boolean') {
+        return;
+      }
+      if (this.config?.experimental?.enableUnifiedMeetings !== changeState) {
+        this.config.experimental.enableUnifiedMeetings = changeState;
+        this.meetingInfo = changeState ? new MeetingInfoV2(this.webex) : new MeetingInfo(this.webex);
+      }
+    }
+
     /**
      * Explicitly sets up the meetings plugin by registering
      * the device, connecting to mercury, and listening for locus events.
@@ -716,7 +735,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
@@ -726,15 +746,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,