@webex/plugin-meetings 1.160.0 → 2.1.0

package/src/meeting/index.js

@@ -646,6 +646,18 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.mediaConnections = null;
+
+    /**
+     * Fetching meeting info can be done randomly 2-5 mins before meeting start
+     * In case it is done before the timer expires, this timeout id is reset to cancel the timer.
+     * @instance
+     * @type {Number}
+     * @readonly
+     * @private
+     * @memberof Meeting
+     */
+    this.fetchMeetingInfoTimeoutId = null;
+
     /**
      * Update the MediaConnections property with new information
      * @param {array} mediaConnections
@@ -908,15 +920,20 @@ export default class Meeting extends StatelessWebexPlugin {
   /**
    * Fetches meeting information.
    * @param {Object} options
-   * @param {String} options.destination
-   * @param {String} options.type
-   * @private
+   * @param {String} [options.password] optional
+   * @param {String} [options.captchaCode] optional
+   * @public
    * @memberof Meeting
    * @returns {Promise}
    */
   async fetchMeetingInfo({
     password = null, captchaCode = null
   }) {
+    // when fetch meeting info is called directly by the client, we want to clear out the random timer for sdk to do it
+    if (this.fetchMeetingInfoTimeoutId) {
+      clearTimeout(this.fetchMeetingInfoTimeoutId);
+      this.fetchMeetingInfoTimeoutId = undefined;
+    }
     if (captchaCode && !this.requiredCaptcha) {
       return Promise.reject(new Error('fetchMeetingInfo() called with captchaCode when captcha was not required'));
     }
@@ -929,7 +946,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
       const info = await this.attrs.meetingInfoProvider.fetchMeetingInfo(this.destination, this.destinationType, password, captchaInfo);
 
-      this.parseMeetingInfo(info);
+      this.parseMeetingInfo(info, this.destination);
       this.meetingInfo = info ? info.body : null;
       this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NONE;
       this.requiredCaptcha = null;
@@ -940,6 +957,15 @@ export default class Meeting extends StatelessWebexPlugin {
         this.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
       }
 
+      Trigger.trigger(
+        this,
+        {
+          file: 'meetings',
+          function: 'fetchMeetingInfo'
+        },
+        EVENT_TRIGGERS.MEETING_INFO_AVAILABLE
+      );
+
       return Promise.resolve();
     }
     catch (err) {
@@ -1485,6 +1511,12 @@ export default class Meeting extends StatelessWebexPlugin {
    *  meeting:recording:stopped
    *  meeting:recording:paused
    *  meeting:recording:resumed
+   *
+   * Set up the locus info meeeting container listener
+   * update meetingContainerUrl value for the meeting
+   * notifies consumer with:
+   *  meeting:meetingContainer:update
+   *
    * @returns {undefined}
    * @private
    * @memberof Meeting
@@ -1529,6 +1561,19 @@ export default class Meeting extends StatelessWebexPlugin {
           this.recording
         );
       });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MEETING_CONTAINER_UPDATED,
+      ({meetingContainerUrl}) => {
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setupLocusControlsListener'
+          },
+          EVENT_TRIGGERS.MEETING_MEETING_CONTAINER_UPDATE,
+          {meetingContainerUrl}
+        );
+      });
   }
 
   /**
@@ -2355,24 +2400,32 @@ export default class Meeting extends StatelessWebexPlugin {
    * @param {String} meetingInfo.body.locusUrl
    * @param {String} meetingInfo.body.sipUri
    * @param {Object} meetingInfo.body.owner
+   * @param {Object | String} destination locus object with meeting data or destination string (sip url, meeting link, etc)
    * @returns {undefined}
    * @private
    * @memberof Meeting
    */
-  parseMeetingInfo(meetingInfo) {
+  parseMeetingInfo(meetingInfo, destination = null) {
     const webexMeetingInfo = meetingInfo?.body;
+    // We try to use as much info from Locus meeting object, stored in destination
+
+    let locusMeetingObject;
+
+    if (destination) {
+      locusMeetingObject = typeof destination === 'object' ? destination : undefined;
+    }
 
     // MeetingInfo will be undefined for 1:1 calls
-    if (webexMeetingInfo && !(meetingInfo.errors && meetingInfo.errors.length > 0)) {
-      this.conversationUrl = webexMeetingInfo.conversationUrl || this.conversationUrl;
-      this.locusUrl = webexMeetingInfo.locusUrl || this.locusUrl;
-      this.setSipUri(this.config.experimental.enableUnifiedMeetings ? webexMeetingInfo.sipUrl : webexMeetingInfo.sipMeetingUri || this.sipUri);
+    if (locusMeetingObject || (webexMeetingInfo && !(meetingInfo?.errors && meetingInfo?.errors.length > 0))) {
+      this.conversationUrl = locusMeetingObject?.conversationUrl || webexMeetingInfo?.conversationUrl || this.conversationUrl;
+      this.locusUrl = locusMeetingObject?.url || webexMeetingInfo?.locusUrl || this.locusUrl;
+      this.setSipUri(this.config.experimental.enableUnifiedMeetings ? locusMeetingObject?.info.sipUri || webexMeetingInfo?.sipUrl : locusMeetingObject?.info.sipUri || webexMeetingInfo?.sipMeetingUri || this.sipUri);
       if (this.config.experimental.enableUnifiedMeetings) {
-        this.meetingNumber = webexMeetingInfo.meetingNumber;
-        this.meetingJoinUrl = webexMeetingInfo.meetingJoinUrl;
+        this.meetingNumber = locusMeetingObject?.info.webExMeetingId || webexMeetingInfo?.meetingNumber;
+        this.meetingJoinUrl = webexMeetingInfo?.meetingJoinUrl;
       }
-      this.owner = webexMeetingInfo.owner || webexMeetingInfo.hostId || this.owner;
-      this.permissionToken = webexMeetingInfo.permissionToken;
+      this.owner = locusMeetingObject?.info.owner || webexMeetingInfo?.owner || webexMeetingInfo?.hostId || this.owner;
+      this.permissionToken = webexMeetingInfo?.permissionToken;
     }
   }
 
@@ -4737,19 +4790,7 @@ export default class Meeting extends StatelessWebexPlugin {
     return MeetingUtil.leaveMeeting(this, options)
       .then((leave) => {
         this.meetingFiniteStateMachine.leave();
-        this.audio = null;
-        this.video = null;
-        this.isSharing = false;
-        if (this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
-          this.shareStatus = SHARE_STATUS.NO_SHARE;
-        }
-        this.queuedMediaUpdates = [];
-
-        if (this.transcription) {
-          this.transcription.closeSocket();
-          this.triggerStopReceivingTranscriptionEvent();
-          this.transcription = undefined;
-        }
+        this.clearMeetingData();
 
         // upload logs on leave irrespective of meeting delete
         Trigger.trigger(
@@ -5635,4 +5676,90 @@ export default class Meeting extends StatelessWebexPlugin {
 
     return (start && end) ? end - start : undefined;
   }
+
+
+  /**
+   * End the current meeting for all
+   * @returns {Promise}
+   * @public
+   * @memberof Meeting
+   */
+  endMeetingForAll() {
+    Metrics.postEvent({event: eventType.LEAVE, meeting: this, data: {trigger: trigger.USER_INTERACTION, canProceed: false}});
+
+    LoggerProxy.logger.log('Meeting:index#endMeetingForAll --> End meeting for All');
+    Metrics.sendBehavioralMetric(
+      BEHAVIORAL_METRICS.MEETING_END_ALL_INITIATED,
+      {
+        correlation_id: this.correlationId,
+        locus_id: this.locusId
+      }
+    );
+
+    return MeetingUtil.endMeetingForAll(this)
+      .then((end) => {
+        this.meetingFiniteStateMachine.end();
+
+        this.clearMeetingData();
+        // upload logs on leave irrespective of meeting delete
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'endMeetingForAll'
+          },
+          EVENTS.REQUEST_UPLOAD_LOGS,
+          this
+        );
+
+        return end;
+      }).catch((error) => {
+        this.meetingFiniteStateMachine.fail(error);
+        LoggerProxy.logger.error('Meeting:index#endMeetingForAll --> Failed to end meeting ', error);
+        // upload logs on leave irrespective of meeting delete
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'endMeetingForAll'
+          },
+          EVENTS.REQUEST_UPLOAD_LOGS,
+          this
+        );
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.MEETING_END_ALL_FAILURE,
+          {
+            correlation_id: this.correlationId,
+            locus_id: this.locusUrl.split('/').pop(),
+            reason: error.message,
+            stack: error.stack,
+            code: error.code
+          }
+        );
+
+        return Promise.reject(error);
+      });
+  }
+
+  /**
+   * clear the meeting data
+   * @returns {undefined}
+   * @public
+   * @memberof Meeting
+   */
+  clearMeetingData = () => {
+    this.audio = null;
+    this.video = null;
+    this.isSharing = false;
+    if (this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
+      this.shareStatus = SHARE_STATUS.NO_SHARE;
+    }
+    this.queuedMediaUpdates = [];
+
+    if (this.transcription) {
+      this.transcription.closeSocket();
+      this.triggerStopReceivingTranscriptionEvent();
+      this.transcription = undefined;
+    }
+  };
 }

package/src/meeting/request.js

@@ -10,6 +10,7 @@ import {
   CALL,
   CONTROLS,
   DECLINE,
+  END,
   FLOOR_ACTION,
   HTTP_VERBS,
   LEAVE,
@@ -647,4 +648,21 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       }
     });
   }
+
+  /**
+   * Make a network request to end meeting for all
+   * @param {Object} options
+   * @param {Url} options.locusUrl
+   * @returns {Promise}
+   */
+  endMeetingForAll({
+    locusUrl,
+  }) {
+    const uri = `${locusUrl}/${END}`;
+
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri
+    });
+  }
 }

package/src/meeting/state.js

@@ -71,7 +71,18 @@ const MeetingStateMachine = {
           ],
           to: MEETING_STATE_MACHINE.STATES.ENDED
         },
-        // when declining an incoming meeting it must be from the ringing state, and it moves to DECLINED state
+        {
+          name: MEETING_STATE_MACHINE.TRANSITIONS.END,
+          from: [
+            MEETING_STATE_MACHINE.STATES.IDLE,
+            MEETING_STATE_MACHINE.STATES.RINGING,
+            MEETING_STATE_MACHINE.STATES.JOINED,
+            MEETING_STATE_MACHINE.STATES.ANSWERED,
+            MEETING_STATE_MACHINE.STATES.DECLINED,
+            MEETING_STATE_MACHINE.STATES.ERROR
+          ],
+          to: MEETING_STATE_MACHINE.STATES.ENDED
+        },
         {
           name: MEETING_STATE_MACHINE.TRANSITIONS.DECLINE,
           from: [MEETING_STATE_MACHINE.STATES.RINGING, MEETING_STATE_MACHINE.STATES.ERROR],

package/src/meeting/util.js

@@ -15,7 +15,7 @@ import {
   STATS,
   EVENT_TRIGGERS,
   FULL_STATE,
-  PASSWORD_STATUS
+  PASSWORD_STATUS,
 } from '../constants';
 import Trigger from '../common/events/trigger-proxy';
 import IntentToJoinError from '../common/errors/intent-to-join';
@@ -744,4 +744,34 @@ MeetingUtil.handleDeviceLogging = (devices = []) => {
   });
 };
 
+MeetingUtil.endMeetingForAll = (meeting) => {
+  if (meeting.meetingState === FULL_STATE.INACTIVE) {
+    return Promise.reject(new MeetingNotActiveError());
+  }
+
+  const endOptions = {
+    locusUrl: meeting.locusUrl,
+  };
+
+  return meeting.meetingRequest
+    .endMeetingForAll(endOptions)
+    .then((response) => {
+      if (response && response.body && response.body.locus) {
+        meeting.locusInfo.onFullLocus(response.body.locus);
+      }
+
+      return Promise.resolve();
+    })
+    .then(() => MeetingUtil.cleanUp(meeting))
+    .catch((err) => {
+      LoggerProxy.logger.error(
+        `Meeting:util#endMeetingForAll An error occured while trying to end meeting for all with an id of ${
+          meeting.id
+        }, error: ${err}`
+      );
+
+      return Promise.reject(err);
+    });
+};
+
 export default MeetingUtil;

package/src/meetings/index.js

@@ -21,6 +21,7 @@ import {
   READY,
   LOCUSEVENT,
   LOCUS_URL,
+  MAX_RANDOM_DELAY_FOR_MEETING_INFO,
   ROAP,
   ONLINE,
   OFFLINE,
@@ -193,12 +194,13 @@ export default class Meetings extends WebexPlugin {
      * @param {Object} data a locus event
      * @param {String} data.locusUrl
      * @param {Object} data.locus
+     * @param {Boolean} useRandomDelayForInfo whether a random delay should be added to fetching meeting info
      * @param {String} data.eventType
      * @returns {undefined}
      * @private
      * @memberof Meetings
      */
-  handleLocusEvent(data) {
+  handleLocusEvent(data, useRandomDelayForInfo = false) {
     let meeting = null;
 
     // getting meeting by correlationId. This will happen for the new event
@@ -255,7 +257,7 @@ export default class Meetings extends WebexPlugin {
         return;
       }
 
-      this.create(data.locus, _LOCUS_ID_).then((newMeeting) => {
+      this.create(data.locus, _LOCUS_ID_, useRandomDelayForInfo).then((newMeeting) => {
         meeting = newMeeting;
 
         // It's a new meeting so initialize the locus data
@@ -307,7 +309,7 @@ export default class Meetings extends WebexPlugin {
     const {eventType} = data;
 
     if (eventType && eventType !== LOCUSEVENT.MESSAGE_ROAP) {
-      this.handleLocusEvent(data);
+      this.handleLocusEvent(data, true);
     }
   }
 
@@ -684,11 +686,12 @@ export default class Meetings extends WebexPlugin {
      * Create a meeting.
      * @param {string} destination - sipURL, spaceId, phonenumber, or locus object}
      * @param {string} [type] - the optional specified type, such as locusId
+     * @param {Boolean} useRandomDelayForInfo - whether a random delay should be added to fetching meeting info
      * @returns {Promise<Meeting>} A new Meeting.
      * @public
      * @memberof Meetings
      */
-  create(destination, type = null) {
+  create(destination, type = null, useRandomDelayForInfo = false) {
     // TODO: type should be from a dictionary
 
     // Validate meeting information based on the provided destination and
@@ -726,11 +729,10 @@ export default class Meetings extends WebexPlugin {
           meeting = this.meetingCollection.getByKey(SIP_URI, targetDest);
         }
 
-
         // Validate if a meeting was found.
         if (!meeting) {
           // Create a meeting based on the normalized destination and type.
-          return this.createMeeting(targetDest, type)
+          return this.createMeeting(targetDest, type, useRandomDelayForInfo)
             .then((createdMeeting) => {
               // If the meeting was successfully created.
               if (createdMeeting && createdMeeting.on) {
@@ -779,11 +781,12 @@ export default class Meetings extends WebexPlugin {
   /**
      * @param {String} destination see create()
      * @param {String} type see create()
+     * @param {Boolean} useRandomDelayForInfo whether a random delay should be added to fetching meeting info
      * @returns {Promise} a new meeting instance complete with meeting info and destination
      * @private
      * @memberof Meetings
      */
-  async createMeeting(destination, type = null) {
+  async createMeeting(destination, type = null, useRandomDelayForInfo = false) {
     const meeting = new Meeting(
       {
         userId: this.webex.internal.device.userId,
@@ -803,7 +806,31 @@ export default class Meetings extends WebexPlugin {
     this.meetingCollection.set(meeting);
 
     try {
-      await meeting.fetchMeetingInfo({});
+      // if no participant has joined the scheduled meeting (meaning meeting is not active) and we get a locusEvent,
+      // it means the meeting will start in 5-6 min. In that case, we want to fetchMeetingInfo
+      // between 5 and 2 min (random between 3 minutes) before the meeting starts
+      // to avoid a spike in traffic to the wbxappi service
+      let waitingTime = 0;
+
+      if (destination.meeting) {
+        const {startTime} = destination.meeting;
+        const startTimeDate = new Date(startTime);
+        const startTimeDatestamp = startTimeDate.getTime();
+        const timeToStart = startTimeDatestamp - Date.now();
+        const maxWaitingTime = Math.max(Math.min(timeToStart, MAX_RANDOM_DELAY_FOR_MEETING_INFO), 0);
+
+        waitingTime = Math.round(Math.random() * maxWaitingTime);
+      }
+      const isMeetingActive = !!destination.fullState?.active;
+      const {enableUnifiedMeetings} = this.config.experimental;
+
+      if (enableUnifiedMeetings && !isMeetingActive && useRandomDelayForInfo && waitingTime > 0) {
+        meeting.fetchMeetingInfoTimeoutId = setTimeout(() => meeting.fetchMeetingInfo({}), waitingTime);
+        meeting.parseMeetingInfo(undefined, destination);
+      }
+      else {
+        await meeting.fetchMeetingInfo({});
+      }
     }
     catch (err) {
       if (!(err instanceof CaptchaError) && !(err instanceof PasswordError)) {

package/src/metrics/constants.js

@@ -13,6 +13,8 @@ const BEHAVIORAL_METRICS = {
   CONNECTION_SUCCESS: 'js_sdk_connection_success',
   CONNECTION_FAILURE: 'js_sdk_connection_failures',
   MEETING_LEAVE_FAILURE: 'js_sdk_meeting_leave_failure',
+  MEETING_END_ALL_FAILURE: 'js_sdk_meeting_end_for_all_failure',
+  MEETING_END_ALL_INITIATED: 'js_sdk_meeting_end_for_all_initiated',
   GET_USER_MEDIA_FAILURE: 'js_sdk_get_user_media_failures',
   GET_DISPLAY_MEDIA_FAILURE: 'js_sdk_get_display_media_failures',
   JOIN_WITH_MEDIA_FAILURE: 'js_sdk_join_with_media_failures',

package/test/unit/spec/locus-info/index.js

@@ -3,6 +3,7 @@ import sinon from 'sinon';
 import {cloneDeep} from 'lodash';
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
+
 import Meetings from '@webex/plugin-meetings';
 import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
@@ -68,7 +69,10 @@ describe('plugin-meetings', () => {
             }
           },
           shareControl: {},
-          transcribe: {}
+          transcribe: {},
+          meetingContainer: {
+            meetingContainerUrl: 'http://new-url.com'
+          }
         };
       });
 
@@ -248,6 +252,52 @@ describe('plugin-meetings', () => {
           lastModified: 'TODAY'
         });
       });
+
+      it('should update the meetingContainerURL from null', () => {
+        locusInfo.controls = {
+          meetingContainer: {meetingContainerUrl: null},
+        };
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(locusInfo.emitScoped, {
+          file: 'locus-info',
+          function: 'updateControls'
+        },
+        LOCUSINFO.EVENTS.CONTROLS_MEETING_CONTAINER_UPDATED,
+        {meetingContainerUrl: 'http://new-url.com'});
+      });
+
+      it('should update the meetingContainerURL from not null', () => {
+        locusInfo.controls = {
+          meetingContainer: {meetingContainerUrl: 'http://old-url.com'},
+        };
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(locusInfo.emitScoped, {
+          file: 'locus-info',
+          function: 'updateControls'
+        },
+        LOCUSINFO.EVENTS.CONTROLS_MEETING_CONTAINER_UPDATED,
+        {meetingContainerUrl: 'http://new-url.com'});
+      });
+
+      it('should update the meetingContainerURL from missing', () => {
+        locusInfo.controls = {};
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(locusInfo.emitScoped, {
+          file: 'locus-info',
+          function: 'updateControls'
+        },
+        LOCUSINFO.EVENTS.CONTROLS_MEETING_CONTAINER_UPDATED,
+        {meetingContainerUrl: 'http://new-url.com'});
+      });
     });
 
     describe('#updateParticipants()', () => {