@webex/plugin-meetings 3.0.0-beta.13 → 3.0.0-beta.131

package/src/meetings/index.ts

@@ -1,8 +1,12 @@
+/* eslint no-shadow: ["error", { "allow": ["eventType"] }] */
+
 import '@webex/internal-plugin-mercury';
 import '@webex/internal-plugin-conversation';
 // @ts-ignore
 import {WebexPlugin} from '@webex/webex-core';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {setLogger} from '@webex/internal-media-core';
+
+import * as mediaHelpersModule from '@webex/media-helpers';
 
 import 'webrtc-adapter';
 
@@ -37,7 +41,11 @@ import {
   _ID_,
   MEETING_REMOVED_REASON,
   _CONVERSATION_URL_,
-  CONVERSATION_URL
+  CONVERSATION_URL,
+  MEETINGNUMBER,
+  BREAKOUTS,
+  _JOINED_,
+  _MOVED_,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import MeetingInfo from '../meeting-info';
@@ -45,12 +53,13 @@ import MeetingInfoV2 from '../meeting-info/meeting-info-v2';
 import Meeting from '../meeting';
 import PersonalMeetingRoom from '../personal-meeting-room';
 import Reachability from '../reachability';
-import Request from '../meetings/request';
+import Request from './request';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 
 import MeetingCollection from './collection';
 import MeetingsUtil from './util';
+import PermissionError from '../common/errors/permission';
 
 let mediaLogger;
 
@@ -80,21 +89,21 @@ class MediaLogger {
   }
 }
 /**
-   * Meetings Ready Event
-   * Emitted when the meetings instance on webex is ready
-   * @event meetings:ready
-   * @instance
-   * @memberof Meetings
-   */
+ * Meetings Ready Event
+ * Emitted when the meetings instance on webex is ready
+ * @event meetings:ready
+ * @instance
+ * @memberof Meetings
+ */
 
 /**
-   * Meetings Network Disconnected Event
-   * Emitted when the meetings instance is disconnected from
-   * the internal mercury server
-   * @event network:disconnected
-   * @instance
-   * @memberof Meetings
-   */
+ * Meetings Network Disconnected Event
+ * Emitted when the meetings instance is disconnected from
+ * the internal mercury server
+ * @event network:disconnected
+ * @instance
+ * @memberof Meetings
+ */
 
 /**
  * Meetings Registered Event
@@ -105,32 +114,32 @@ class MediaLogger {
  */
 
 /**
-    * Meeting Removed Event
-    * Emitted when a meeting was removed from the cache of meetings
-    * @event meeting:removed
-    * @instance
-    * @type {Object}
-    * @property {String} meetingId the removed meeting
-    * @property {Object} response the server response
-    * @property {String} type what type of meeting it was
-    * @memberof Meetings
-    */
+ * Meeting Removed Event
+ * Emitted when a meeting was removed from the cache of meetings
+ * @event meeting:removed
+ * @instance
+ * @type {Object}
+ * @property {String} meetingId the removed meeting
+ * @property {Object} response the server response
+ * @property {String} type what type of meeting it was
+ * @memberof Meetings
+ */
 
 /**
-    * Meeting Added Event
-    * Emitted when a meeting was added to the cache of meetings
-    * @event meeting:added
-    * @instance
-    * @type {Object}
-    * @property {String} meetingId the added meeting
-    * @property {String} type what type of meeting it was
-    * @memberof Meetings
-    */
+ * Meeting Added Event
+ * Emitted when a meeting was added to the cache of meetings
+ * @event meeting:added
+ * @instance
+ * @type {Object}
+ * @property {String} meetingId the added meeting
+ * @property {String} type what type of meeting it was
+ * @memberof Meetings
+ */
 
 /**
-   * Maintain a cache of meetings and sync with services.
-   * @class
-   */
+ * Maintain a cache of meetings and sync with services.
+ * @class
+ */
 export default class Meetings extends WebexPlugin {
   loggerRequest: any;
   media: any;
@@ -142,120 +151,272 @@ export default class Meetings extends WebexPlugin {
   request: any;
   geoHintInfo: any;
   meetingInfo: any;
-
+  mediaHelpers: any;
+  breakoutLocusForHandleLater: any;
   namespace = MEETINGS;
 
   /**
-     * Initializes the Meetings Plugin
-     * @constructor
-     * @public
-     * @memberof Meetings
-     */
+   * Initializes the Meetings Plugin
+   * @constructor
+   * @public
+   * @memberof Meetings
+   */
   constructor(...args) {
     super(...args);
 
     /**
-       * The Meetings request to interact with server
-       * @instance
-       * @type {Object}
-       * @private
-       * @memberof Meetings
-       */
+     * The webrtc-core media helpers. This is a temporary solution required for the SDK sample app
+     * to be able to call media helper functions.
+     *
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Meetings
+     */
+    this.mediaHelpers = mediaHelpersModule;
+
+    /**
+     * The Meetings request to interact with server
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Meetings
+     */
     // @ts-ignore
     this.request = new Request({}, {parent: this.webex});
     /**
-       * Log upload request helper
-       * @instance
-       * @type {Object}
-       * @private
-       * @memberof Meetings
-       */
+     * Log upload request helper
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Meetings
+     */
     // @ts-ignore
     this.loggerRequest = new LoggerRequest({webex: this.webex});
     this.meetingCollection = new MeetingCollection();
     /**
-       * The PersonalMeetingRoom object to interact with server
-       * @instance
-       * @type {Object}
-       * @public
-       * @memberof Meetings
-       */
+     * The PersonalMeetingRoom object to interact with server
+     * @instance
+     * @type {Object}
+     * @public
+     * @memberof Meetings
+     */
     this.personalMeetingRoom = null;
     /**
-       * The Reachability object to interact with server, starts as null until {@link Meeting#setReachability} is called
-       * starts as null
-       * @instance
-       * @type {Object}
-       * @private
-       * @memberof Meetings
-       */
+     * The Reachability object to interact with server, starts as null until {@link Meeting#setReachability} is called
+     * starts as null
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Meetings
+     */
     this.reachability = null;
 
     /**
-       * If the meetings plugin has been registered and listening via {@link Meetings#register}
-       * @instance
-       * @type {Boolean}
-       * @public
-       * @memberof Meetings
-       */
+     * If the meetings plugin has been registered and listening via {@link Meetings#register}
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Meetings
+     */
     this.registered = false;
 
     /**
-       * This values indicates the preferred webex site the user will start there meeting, getsits value from {@link Meetings#register}
-       * @instance
-       * @type {String}
-       * @private
-       * @memberof Meetings
-       */
+     * This values indicates the preferred webex site the user will start there meeting, getsits value from {@link Meetings#register}
+     * @instance
+     * @type {String}
+     * @private
+     * @memberof Meetings
+     */
     this.preferredWebexSite = '';
 
     /**
-       * The public interface for the internal Media util files. These are helpful to expose outside the context
-       * of a meeting so that a user can access media without creating a meeting instance.
-       * @instance
-       * @type {Object}
-       * @private
-       * @memberof Meetings
-       */
+     * The public interface for the internal Media util files. These are helpful to expose outside the context
+     * of a meeting so that a user can access media without creating a meeting instance.
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Meetings
+     */
     this.media = {
       getUserMedia: Media.getUserMedia,
-      getSupportedDevice: Media.getSupportedDevice
+      getSupportedDevice: Media.getSupportedDevice,
     };
 
     this.onReady();
   }
 
   /**
-     * handle locus events and takes meeting actions with them as they come in
-     * @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
-     */
-  private handleLocusEvent(data: { locusUrl: string; locus: any }, useRandomDelayForInfo: boolean = false) {
-    let meeting = null;
+   * check whether you need to handle this main session's locus data or not
+   * @param {Object} meeting current meeting data
+   * @param {Object} newLocus new locus data
+   * @returns {boolean}
+   * @private
+   * @memberof Meetings
+   */
+  private isNeedHandleMainLocus(meeting: any, newLocus: any) {
+    const breakoutUrl = newLocus.controls?.breakout?.url;
+    const breakoutLocus = this.meetingCollection.getActiveBreakoutLocus(breakoutUrl);
+
+    const isSelfJoined = newLocus?.self?.state === _JOINED_;
+    const isSelfMoved = newLocus?.self?.state === _LEFT_ && newLocus?.self?.reason === _MOVED_;
+    // @ts-ignore
+    const deviceFromNewLocus = MeetingsUtil.getThisDevice(newLocus, this.webex.internal.device.url);
+    const isNewLocusJoinThisDevice = MeetingsUtil.joinedOnThisDevice(
+      meeting,
+      newLocus,
+      // @ts-ignore
+      this.webex.internal.device.url
+    );
+    const isBreakoutLocusJoinThisDevice =
+      breakoutLocus?.joinedWith?.correlationId &&
+      breakoutLocus.joinedWith.correlationId === meeting?.correlationId;
 
+    if (isSelfJoined && isNewLocusJoinThisDevice) {
+      LoggerProxy.logger.log(
+        'Meetings:index#isNeedHandleMainLocus --> self this device shown as JOINED in the main session'
+      );
+      if (breakoutLocus?.joinedWith && deviceFromNewLocus) {
+        const breakoutReplaceAt =
+          breakoutLocus.joinedWith.replaces?.length > 0
+            ? breakoutLocus.joinedWith.replaces[0].replaceAt
+            : '';
+        const newLocusReplaceAt =
+          deviceFromNewLocus.replaces?.length > 0 ? deviceFromNewLocus.replaces[0].replaceAt : '';
+        if (breakoutReplaceAt && newLocusReplaceAt && breakoutReplaceAt > newLocusReplaceAt) {
+          LoggerProxy.logger.log(
+            `Meetings:index#isNeedHandleMainLocus --> this is expired main joined status locus_dto replacedAt ${newLocusReplaceAt} bo replacedAt ${breakoutReplaceAt}`
+          );
+
+          return false;
+        }
+      }
+
+      return true;
+    }
+    if (isBreakoutLocusJoinThisDevice) {
+      LoggerProxy.logger.log(
+        `Meetings:index#isNeedHandleMainLocus --> there is active breakout session and joined on this device, and don't need to handle main session: ${breakoutUrl}`
+      );
+
+      return false;
+    }
+    if (isSelfMoved && newLocus?.self?.removed) {
+      LoggerProxy.logger.log(
+        'Meetings:index#isNeedHandleMainLocus --> self moved main locus with self removed status, not need to handle'
+      );
+
+      return false;
+    }
+    LoggerProxy.logger.log(
+      'Meetings:index#isNeedHandleMainLocus --> this is a normal main session locusDTO update case'
+    );
+
+    return true;
+  }
+
+  /**
+   * check whether you need to handle this locus data or not
+   * @param {Object} meeting old locus data
+   * @param {Object} newLocus new locus data
+   * @returns {boolean}
+   * @private
+   * @memberof Meetings
+   */
+  private isNeedHandleLocusDTO(meeting: any, newLocus: any) {
+    if (newLocus) {
+      const isNewLocusAsBreakout = MeetingsUtil.isBreakoutLocusDTO(newLocus);
+      const isSelfMoved = newLocus?.self?.state === _LEFT_ && newLocus?.self?.reason === _MOVED_;
+      if (!meeting) {
+        if (isNewLocusAsBreakout) {
+          LoggerProxy.logger.log(
+            `Meetings:index#isNeedHandleLocusDTO --> the first breakout session locusDTO active status: ${newLocus.fullState?.active}`
+          );
+
+          return newLocus.self?.state === _JOINED_;
+        }
+
+        return this.isNeedHandleMainLocus(meeting, newLocus);
+      }
+      if (!isNewLocusAsBreakout) {
+        return this.isNeedHandleMainLocus(meeting, newLocus);
+      }
+
+      return !isSelfMoved;
+    }
+
+    return true;
+  }
+
+  /**
+   * get corresponding meeting object by locus data
+   * @param {Object} data a locus event
+   * @param {String} data.locusUrl
+   * @param {Object} data.locus
+   * @returns {Object}
+   * @private
+   * @memberof Meetings
+   */
+  getCorrespondingMeetingByLocus(data) {
     // getting meeting by correlationId. This will happen for the new event
     // Either the locus
     // TODO : Add check for the callBack Address
-    meeting = this.meetingCollection.getByKey(LOCUS_URL, data.locusUrl) ||
-    // @ts-ignore
-      this.meetingCollection.getByKey(CORRELATION_ID, MeetingsUtil.checkForCorrelationId(this.webex.internal.device.url, data.locus)) ||
-      this.meetingCollection.getByKey(SIP_URI, data.locus.self && data.locus.self.callbackInfo && data.locus.self.callbackInfo.callbackAddress) ||
-      (data.locus.info?.isUnifiedSpaceMeeting ? undefined : this.meetingCollection.getByKey(CONVERSATION_URL, data.locus.conversationUrl));
+    return (
+      this.meetingCollection.getByKey(LOCUS_URL, data.locusUrl) ||
+      // @ts-ignore
+      this.meetingCollection.getByKey(
+        CORRELATION_ID,
+        // @ts-ignore
+        MeetingsUtil.checkForCorrelationId(this.webex.internal.device.url, data.locus)
+      ) ||
+      this.meetingCollection.getByKey(
+        SIP_URI,
+        data.locus.self &&
+          data.locus.self.callbackInfo &&
+          data.locus.self.callbackInfo.callbackAddress
+      ) ||
+      (data.locus.info?.isUnifiedSpaceMeeting
+        ? undefined
+        : this.meetingCollection.getByKey(CONVERSATION_URL, data.locus.conversationUrl)) ||
+      this.meetingCollection.getByKey(MEETINGNUMBER, data.locus?.info?.webExMeetingId)
+    );
+  }
+
+  /**
+   * handle locus events and takes meeting actions with them as they come in
+   * @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
+   */
+  private handleLocusEvent(data: {locusUrl: string; locus: any}, useRandomDelayForInfo = false) {
+    let meeting = this.getCorrespondingMeetingByLocus(data);
 
     // Special case when locus has got replaced, This only happend once if a replace locus exists
     // https://sqbu-github.cisco.com/WebExSquared/locus/wiki/Locus-changing-mid-call
 
     if (!meeting && data.locus?.replaces?.length > 0) {
       // Always the last element in the replace is the active one
-      meeting = this.meetingCollection.getByKey(LOCUS_URL, data.locus.replaces[data.locus.replaces.length - 1].locusUrl);
+      meeting = this.meetingCollection.getByKey(
+        LOCUS_URL,
+        data.locus.replaces[data.locus.replaces.length - 1].locusUrl
+      );
+    }
+
+    if (meeting && !MeetingsUtil.isBreakoutLocusDTO(data.locus)) {
+      meeting.locusInfo.updateMainSessionLocusCache(data.locus);
     }
+    if (!this.isNeedHandleLocusDTO(meeting, data.locus)) {
+      LoggerProxy.logger.log(
+        `Meetings:index#handleLocusEvent --> doesn't need to process locus event`
+      );
 
+      return;
+    }
     if (!meeting) {
       // TODO: create meeting when we get a meeting object
       // const checkForEnded = (locus) => {
@@ -276,73 +437,93 @@ export default class Meetings extends WebexPlugin {
       // };
       // rather then locus object change to locus url
 
-      if (data.locus && data.locus.fullState && data.locus.fullState.state === LOCUS.STATE.INACTIVE) {
+      if (
+        data.locus &&
+        data.locus.fullState &&
+        data.locus.fullState.state === LOCUS.STATE.INACTIVE
+      ) {
         // just ignore the event as its already ended and not active
-        LoggerProxy.logger.warn('Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.');
+        LoggerProxy.logger.warn(
+          'Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.'
+        );
 
         return;
       }
 
-
       // When its wireless share or guest and user leaves the meeting we dont have to keep the meeting object
       // Any future events will be neglected
 
-      if (data.locus && data.locus.self && (data.locus.self.state === _LEFT_ && data.locus.self.removed === true)) {
+      if (
+        data.locus &&
+        data.locus.self &&
+        data.locus.self.state === _LEFT_ &&
+        data.locus.self.removed === true
+      ) {
         // just ignore the event as its already ended and not active
-        LoggerProxy.logger.warn('Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.');
+        LoggerProxy.logger.warn(
+          'Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.'
+        );
 
         return;
       }
 
-      this.create(data.locus, _LOCUS_ID_, useRandomDelayForInfo).then((newMeeting) => {
-        meeting = newMeeting;
-
-        // It's a new meeting so initialize the locus data
-        meeting.locusInfo.initialSetup(data.locus);
-      }).catch((e) => {
-        console.log(e);
-      })
+      this.create(data.locus, _LOCUS_ID_, useRandomDelayForInfo)
+        .then((newMeeting) => {
+          meeting = newMeeting;
+
+          // It's a new meeting so initialize the locus data
+          meeting.locusInfo.initialSetup(data.locus);
+          this.checkHandleBreakoutLocus(data.locus);
+        })
+        .catch((e) => {
+          LoggerProxy.logger.error(e);
+        })
         .finally(() => {
           // There will be cases where locus event comes in gets created and deleted because its a 1:1 and meeting gets deleted
           // because the other user left so before sending 'added' event make sure it exists in the collection
 
           if (this.getMeetingByType(_ID_, meeting.id)) {
-            Metrics.postEvent({event: eventType.REMOTE_STARTED, meeting, data: {trigger: trigger.MERCURY_EVENT}});
+            Metrics.postEvent({
+              event: eventType.REMOTE_STARTED,
+              meeting,
+              data: {trigger: trigger.MERCURY_EVENT},
+            });
             Trigger.trigger(
               this,
               {
                 file: 'meetings',
-                function: 'handleLocusEvent'
+                function: 'handleLocusEvent',
               },
               EVENT_TRIGGERS.MEETING_ADDED,
               {
                 meeting,
-                type: meeting.type === _MEETING_ ? _JOIN_ : _INCOMING_
+                type: meeting.type === _MEETING_ ? _JOIN_ : _INCOMING_,
               }
             );
-          }
-          else {
+          } else {
             // Meeting got added but was not found in the collection. It might have got destroyed
-            LoggerProxy.logger.warn('Meetings:index#handleLocusEvent --> Created and destroyed meeting object before sending an event');
+            LoggerProxy.logger.warn(
+              'Meetings:index#handleLocusEvent --> Created and destroyed meeting object before sending an event'
+            );
           }
         });
-    }
-    else {
+    } else {
       meeting.locusInfo.parse(meeting, data);
     }
   }
 
   /**
-     * handles locus events through mercury that are not roap
-     * @param {Object} envelope
-     * @param {Object} envelope.data
-     * @param {String} envelope.data.eventType
-     * @returns {undefined}
-     * @private
-     * @memberof Meetings
-     */
-  private handleLocusMercury(envelope: { data: any }) {
+   * handles locus events through mercury that are not roap
+   * @param {Object} envelope
+   * @param {Object} envelope.data
+   * @param {String} envelope.data.eventType
+   * @returns {undefined}
+   * @private
+   * @memberof Meetings
+   */
+  private handleLocusMercury(envelope: {data: any}) {
     const {data} = envelope;
+    // eslint-disable-next-line @typescript-eslint/no-shadow
     const {eventType} = data;
 
     if (eventType && eventType !== LOCUSEVENT.MESSAGE_ROAP) {
@@ -350,31 +531,29 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
-
   /**
-     * handles mecury offline event
-     * @returns {undefined}
-     * @private
-     * @memberof Meetings
-     */
+   * handles mecury offline event
+   * @returns {undefined}
+   * @private
+   * @memberof Meetings
+   */
   private handleMercuryOffline() {
     Trigger.trigger(
       this,
       {
         file: 'meetings/index',
-        function: 'handleMercuryOffline'
+        function: 'handleMercuryOffline',
       },
-      EVENT_TRIGGERS.MEETINGS_NETWORK_DISCONNECTED,
+      EVENT_TRIGGERS.MEETINGS_NETWORK_DISCONNECTED
     );
   }
 
-
   /**
-     * registers for locus and roap mercury events
-     * @returns {undefined}
-     * @private
-     * @memberof Meetings
-     */
+   * registers for locus and roap mercury events
+   * @returns {undefined}
+   * @private
+   * @memberof Meetings
+   */
   private listenForEvents() {
     // @ts-ignore
     this.webex.internal.mercury.on(LOCUSEVENT.LOCUS_MERCURY, (envelope) => {
@@ -397,11 +576,11 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * stops listening for locus and roap mercury events
-     * @returns {undefined}
-     * @private
-     * @memberof Meetings
-     */
+   * stops listening for locus and roap mercury events
+   * @returns {undefined}
+   * @private
+   * @memberof Meetings
+   */
   private stopListeningForEvents() {
     // @ts-ignore
     this.webex.internal.mercury.off(LOCUSEVENT.LOCUS_MERCURY);
@@ -412,10 +591,10 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * @returns {undefined}
-     * @private
-     * @memberof Meetings
-     */
+   * @returns {undefined}
+   * @private
+   * @memberof Meetings
+   */
   private onReady() {
     // @ts-ignore
     this.webex.once(READY, () => {
@@ -427,7 +606,7 @@ export default class Meetings extends WebexPlugin {
       LoggerProxy.set(this.webex.logger);
 
       mediaLogger = new MediaLogger();
-      MC.setLogger(mediaLogger);
+      setLogger(mediaLogger);
 
       /**
        * The MeetingInfo object to interact with server
@@ -437,15 +616,23 @@ export default class Meetings extends WebexPlugin {
        * @memberof Meetings
        */
       // @ts-ignore
-      this.meetingInfo = this.config.experimental.enableUnifiedMeetings ? new MeetingInfoV2(this.webex) : new MeetingInfo(this.webex);
+      this.meetingInfo = this.config.experimental.enableUnifiedMeetings
+        ? // @ts-ignore
+          new MeetingInfoV2(this.webex)
+        : // @ts-ignore
+          new MeetingInfo(this.webex);
       // @ts-ignore
-      this.personalMeetingRoom = new PersonalMeetingRoom({meetingInfo: this.meetingInfo}, {parent: this.webex});
+      this.personalMeetingRoom = new PersonalMeetingRoom(
+        {meetingInfo: this.meetingInfo},
+        // @ts-ignore
+        {parent: this.webex}
+      );
 
       Trigger.trigger(
         this,
         {
           file: 'meetings',
-          function: 'onReady'
+          function: 'onReady',
         },
         EVENT_TRIGGERS.MEETINGS_READY
       );
@@ -457,12 +644,12 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * API to toggle unified meetings
-     * @param {Boolean} changeState
-     * @private
-     * @memberof Meetings
-     * @returns {undefined}
-    */
+   * API to toggle unified meetings
+   * @param {Boolean} changeState
+   * @private
+   * @memberof Meetings
+   * @returns {undefined}
+   */
   private _toggleUnifiedMeetings(changeState: boolean) {
     if (typeof changeState !== 'boolean') {
       return;
@@ -477,12 +664,12 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * API to enable or disable TURN discovery
-     * @param {Boolean} enable
-     * @private
-     * @memberof Meetings
-     * @returns {undefined}
-    */
+   * API to enable or disable TURN discovery
+   * @param {Boolean} enable
+   * @private
+   * @memberof Meetings
+   * @returns {undefined}
+   */
   private _toggleTurnDiscovery(enable: boolean) {
     if (typeof enable !== 'boolean') {
       return;
@@ -492,12 +679,12 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * API to toggle starting adhoc meeting
-     * @param {Boolean} changeState
-     * @private
-     * @memberof Meetings
-     * @returns {undefined}
-    */
+   * API to toggle starting adhoc meeting
+   * @param {Boolean} changeState
+   * @private
+   * @memberof Meetings
+   * @returns {undefined}
+   */
   private _toggleAdhocMeetings(changeState: boolean) {
     if (typeof changeState !== 'boolean') {
       return;
@@ -510,24 +697,27 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * Explicitly sets up the meetings plugin by registering
-     * the device, connecting to mercury, and listening for locus events.
-     *
-     * @returns {Promise}
-     * @public
-     * @memberof Meetings
-     */
+   * Explicitly sets up the meetings plugin by registering
+   * the device, connecting to mercury, and listening for locus events.
+   *
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
   public register() {
     // @ts-ignore
     if (!this.webex.canAuthorize) {
-      LoggerProxy.logger.error('Meetings:index#register --> ERROR, Unable to register, SDK cannot authorize');
+      LoggerProxy.logger.error(
+        'Meetings:index#register --> ERROR, Unable to register, SDK cannot authorize'
+      );
 
       return Promise.reject(new Error('SDK cannot authorize'));
     }
 
-
     if (this.registered) {
-      LoggerProxy.logger.info('Meetings:index#register --> INFO, Meetings plugin already registered');
+      LoggerProxy.logger.info(
+        'Meetings:index#register --> INFO, Meetings plugin already registered'
+      );
 
       return Promise.resolve();
     }
@@ -539,88 +729,97 @@ export default class Meetings extends WebexPlugin {
         LoggerProxy.logger.error(`Meetings:index#register --> GDM error, ${error.message}`);
       }),
       // @ts-ignore
-      this.webex.internal.device.register()
-      // @ts-ignore
-        .then(() => LoggerProxy.logger.info(`Meetings:index#register --> INFO, Device registered ${this.webex.internal.device.url}`))
+      this.webex.internal.device
+        .register()
+        // @ts-ignore
+        .then(() =>
+          LoggerProxy.logger.info(
+            // @ts-ignore
+            `Meetings:index#register --> INFO, Device registered ${this.webex.internal.device.url}`
+          )
+        )
         // @ts-ignore
         .then(() => this.webex.internal.mercury.connect()),
-      MeetingsUtil.checkH264Support.call(this)
-    ]).then(() => {
-      this.listenForEvents();
-      Trigger.trigger(
-        this,
-        {
-          file: 'meetings',
-          function: 'register'
-        },
-        EVENT_TRIGGERS.MEETINGS_REGISTERED
-      );
-      this.registered = true;
-      Metrics.sendBehavioralMetric(
-        BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_SUCCESS,
-      );
-    })
-      .catch((error) => {
-        LoggerProxy.logger.error(`Meetings:index#register --> ERROR, Unable to register, ${error.message}`);
-
-        Metrics.sendBehavioralMetric(
-          BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_FAILED,
+      MeetingsUtil.checkH264Support.call(this),
+    ])
+      .then(() => {
+        this.listenForEvents();
+        Trigger.trigger(
+          this,
           {
-            reason: error.message,
-            stack: error.stack
-          }
+            file: 'meetings',
+            function: 'register',
+          },
+          EVENT_TRIGGERS.MEETINGS_REGISTERED
+        );
+        this.registered = true;
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_SUCCESS);
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error(
+          `Meetings:index#register --> ERROR, Unable to register, ${error.message}`
         );
 
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_FAILED, {
+          reason: error.message,
+          stack: error.stack,
+        });
+
         return Promise.reject(error);
       });
   }
 
   /**
-     * Explicitly tears down the meetings plugin by deregistering
-     * the device, disconnecting from mercury, and stops listening to locus events
-     *
-     * @returns {Promise}
-     * @public
-     * @memberof Meetings
-     */
+   * Explicitly tears down the meetings plugin by deregistering
+   * the device, disconnecting from mercury, and stops listening to locus events
+   *
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
   unregister() {
     if (!this.registered) {
-      LoggerProxy.logger.info('Meetings:index#unregister --> INFO, Meetings plugin already unregistered');
+      LoggerProxy.logger.info(
+        'Meetings:index#unregister --> INFO, Meetings plugin already unregistered'
+      );
 
       return Promise.resolve();
     }
 
     this.stopListeningForEvents();
 
-    // @ts-ignore
-    return this.webex.internal.mercury.disconnect()
-    // @ts-ignore
-      .then(() => this.webex.internal.device.unregister())
-      .then(() => {
-        Trigger.trigger(
-          this,
-          {
-            file: 'meetings',
-            function: 'unregister'
-          },
-          EVENT_TRIGGERS.MEETINGS_UNREGISTERED
-        );
-        this.registered = false;
-      });
+    return (
+      // @ts-ignore
+      this.webex.internal.mercury
+        .disconnect()
+        // @ts-ignore
+        .then(() => this.webex.internal.device.unregister())
+        .then(() => {
+          Trigger.trigger(
+            this,
+            {
+              file: 'meetings',
+              function: 'unregister',
+            },
+            EVENT_TRIGGERS.MEETINGS_UNREGISTERED
+          );
+          this.registered = false;
+        })
+    );
   }
 
   /**
-     * Uploads logs to the webex services for tracking
-     * @param {Object} [options={}]
-     * @param {String} [options.callStart] Call Start Time
-     * @param {String} [options.feedbackId] ID used for tracking
-     * @param {String} [options.locusId]
-     * @param {String} [options.correlationId]
-     * @param {String} [options.meetingId] webex meeting ID
-     * @param {String} [options.userId] userId
-     * @param {String} [options.orgId] org id
-     * @returns {String} feedback ID logs were submitted under
-     */
+   * Uploads logs to the webex services for tracking
+   * @param {Object} [options={}]
+   * @param {String} [options.callStart] Call Start Time
+   * @param {String} [options.feedbackId] ID used for tracking
+   * @param {String} [options.locusId]
+   * @param {String} [options.correlationId]
+   * @param {String} [options.meetingId] webex meeting ID
+   * @param {String} [options.userId] userId
+   * @param {String} [options.orgId] org id
+   * @returns {String} feedback ID logs were submitted under
+   */
   uploadLogs(
     options: {
       callStart?: string;
@@ -634,79 +833,83 @@ export default class Meetings extends WebexPlugin {
   ) {
     LoggerProxy.logger.info('Meetings:index#uploadLogs --> uploading logs');
 
-    return this.loggerRequest.uploadLogs(options)
+    return this.loggerRequest
+      .uploadLogs(options)
       .then((uploadResult) => {
-        LoggerProxy.logger.info('Meetings:index#uploadLogs --> Upload logs for meeting completed.', uploadResult);
+        LoggerProxy.logger.info(
+          'Meetings:index#uploadLogs --> Upload logs for meeting completed.',
+          uploadResult
+        );
         Trigger.trigger(
           this,
           {
             file: 'meetings',
-            function: 'uploadLogs'
+            function: 'uploadLogs',
           },
           EVENT_TRIGGERS.MEETING_LOG_UPLOAD_SUCCESS,
           {
             meetingId: options.meetingId,
-            details: uploadResult
+            details: uploadResult,
           }
         );
 
         return uploadResult;
       })
       .catch((uploadError) => {
-        LoggerProxy.logger.error('Meetings:index#uploadLogs --> Unable to upload logs for meeting', uploadError);
+        LoggerProxy.logger.error(
+          'Meetings:index#uploadLogs --> Unable to upload logs for meeting',
+          uploadError
+        );
         Trigger.trigger(
           this,
           {
             file: 'meetings',
-            function: 'uploadLogs'
+            function: 'uploadLogs',
           },
           EVENT_TRIGGERS.MEETING_LOG_UPLOAD_FAILURE,
           {
             meetingId: options.meetingId,
-            reason: uploadError
+            reason: uploadError,
           }
         );
 
-        Metrics.sendBehavioralMetric(
-          BEHAVIORAL_METRICS.UPLOAD_LOGS_FAILURE,
-          {
-            // @ts-ignore - seems like typo
-            meetingId: options.meetingsId,
-            reason: uploadError.message,
-            stack: uploadError.stack,
-            code: uploadError.code
-          }
-        );
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.UPLOAD_LOGS_FAILURE, {
+          // @ts-ignore - seems like typo
+          meetingId: options.meetingsId,
+          reason: uploadError.message,
+          stack: uploadError.stack,
+          code: uploadError.code,
+        });
       });
   }
 
   /**
-     * initializes the reachability instance for Meetings
-     * @returns {undefined}
-     * @public
-     * @memberof Meetings
-     */
+   * initializes the reachability instance for Meetings
+   * @returns {undefined}
+   * @public
+   * @memberof Meetings
+   */
   setReachability() {
     // @ts-ignore
     this.reachability = new Reachability(this.webex);
   }
 
   /**
-     * gets the reachability instance for Meetings
-     * @returns {Reachability}
-     * @public
-     * @memberof Meetings
-     */
+   * gets the reachability instance for Meetings
+   * @returns {Reachability}
+   * @public
+   * @memberof Meetings
+   */
   getReachability() {
     return this.reachability;
   }
 
   /**
-     * initializes and starts gathering reachability for Meetings
-     * @returns {Promise}
-     * @public
-     * @memberof Meetings
-     */
+   * initializes and starts gathering reachability for Meetings
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
   startReachability() {
     if (!this.reachability) {
       this.setReachability();
@@ -716,11 +919,11 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * Get geoHint for info for meetings
-     * @returns {Promise}
-     * @private
-     * @memberof Meetings
-     */
+   * Get geoHint for info for meetings
+   * @returns {Promise}
+   * @private
+   * @memberof Meetings
+   */
   getGeoHint() {
     return this.request.fetchGeoHint().then((res) => {
       this.geoHintInfo = res;
@@ -728,39 +931,62 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * Fetch user preferred webex site information
-     * This also has other infomation about the user
-     * @returns {Promise}
-     * @private
-     * @memberof Meetings
-     */
+   * Fetch user preferred webex site information
+   * This also has other infomation about the user
+   * @returns {Promise}
+   * @private
+   * @memberof Meetings
+   */
   fetchUserPreferredWebexSite() {
     return this.request.getMeetingPreferences().then((res) => {
       if (res) {
         this.preferredWebexSite = MeetingsUtil.parseDefaultSiteFromMeetingPreferences(res);
       }
+
+      // fall back to getting the preferred site from the user information
+      if (!this.preferredWebexSite) {
+        // @ts-ignore
+        return this.webex.internal.user
+          .get()
+          .then((user) => {
+            const preferredWebexSite =
+              user?.userPreferences?.userPreferencesItems?.preferredWebExSite;
+            if (preferredWebexSite) {
+              this.preferredWebexSite = preferredWebexSite;
+            } else {
+              throw new Error('site not found');
+            }
+          })
+          .catch(() => {
+            LoggerProxy.logger.error(
+              'Failed to fetch preferred site from user - no site will be set'
+            );
+          });
+      }
+
+      return Promise.resolve();
     });
   }
 
   /**
-     * gets the personal meeting room instance, for saved PMR values for this user
-     * @returns {PersonalMeetingRoom}
-     * @public
-     * @memberof Meetings
-     */
+   * gets the personal meeting room instance, for saved PMR values for this user
+   * @returns {PersonalMeetingRoom}
+   * @public
+   * @memberof Meetings
+   */
 
   getPersonalMeetingRoom() {
     return this.personalMeetingRoom;
   }
 
   /**
-     * @param {Meeting} meeting
-     * @param {Object} reason
-     * @param {String} type
-     * @returns {Undefined}
-     * @private
-     * @memberof Meetings
-     */
+   * @param {Meeting} meeting
+   * @param {Object} reason
+   * @param {String} type
+   * @returns {Undefined}
+   * @private
+   * @memberof Meetings
+   */
   private destroy(meeting: Meeting, reason: object) {
     MeetingUtil.cleanUp(meeting);
     this.meetingCollection.delete(meeting.id);
@@ -768,68 +994,82 @@ export default class Meetings extends WebexPlugin {
       this,
       {
         file: 'meetings',
-        function: 'destroy'
+        function: 'destroy',
       },
       EVENT_TRIGGERS.MEETING_REMOVED,
       {
         meetingId: meeting.id,
-        reason
+        reason,
       }
     );
   }
 
   /**
-     * 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
-     */
-  public create(destination: string, type: string = null, useRandomDelayForInfo: boolean = false) {
+   * 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
+   * @param {Object} infoExtraParams extra parameters to be provided when fetching meeting info
+   * @returns {Promise<Meeting>} A new Meeting.
+   * @public
+   * @memberof Meetings
+   */
+  public create(
+    destination: string,
+    type: string = null,
+    useRandomDelayForInfo = false,
+    infoExtraParams = {}
+  ) {
     // TODO: type should be from a dictionary
 
     // Validate meeting information based on the provided destination and
     // type. This must be performed prior to determining if the meeting is
     // found in the collection, as we mutate the destination for hydra person
     // id values.
-    return this.meetingInfo.fetchInfoOptions(destination, type)
-    // Catch a failure to fetch info options.
-      .catch((error) => {
-        LoggerProxy.logger.info(`Meetings:index#create --> INFO, unable to determine info options: ${error.message}`);
-      })
-      .then((options: any = {}) => {
-        // Normalize the destination.
-        const targetDest = options.destination || destination;
-
-        // check for the conversation URL then sip Url
-        let meeting = null;
-
-        if (type === _CONVERSATION_URL_ || options.type === _CONVERSATION_URL_) {
-          const foundMeeting = this.meetingCollection.getByKey(CONVERSATION_URL, targetDest);
-
-          if (foundMeeting) {
-            const foundMeetingIsNotCalendarMeeting = !foundMeeting.locusInfo.scheduledMeeting;
-
-            // If the found meeting is not a calendar meeting, return that meeting.
-            // This allows for the creation of instant-meetings when calendar meetings are present.
-            if (foundMeetingIsNotCalendarMeeting) {
-              meeting = foundMeeting;
+    return (
+      this.meetingInfo
+        .fetchInfoOptions(destination, type)
+        // Catch a failure to fetch info options.
+        .catch((error) => {
+          LoggerProxy.logger.info(
+            `Meetings:index#create --> INFO, unable to determine info options: ${error.message}`
+          );
+        })
+        .then((options: any = {}) => {
+          // Normalize the destination.
+          const targetDest = options.destination || destination;
+
+          // check for the conversation URL then sip Url
+          let meeting = null;
+
+          if (type === _CONVERSATION_URL_ || options.type === _CONVERSATION_URL_) {
+            const foundMeeting = this.meetingCollection.getByKey(CONVERSATION_URL, targetDest);
+
+            if (foundMeeting) {
+              const foundMeetingIsNotCalendarMeeting = !foundMeeting.locusInfo.scheduledMeeting;
+
+              // If the found meeting is not a calendar meeting, return that meeting.
+              // This allows for the creation of instant-meetings when calendar meetings are present.
+              if (foundMeetingIsNotCalendarMeeting) {
+                meeting = foundMeeting;
+              }
             }
           }
-        }
 
-        // Attempt to collect the meeting if it exists.
-        if (!meeting) {
-          meeting = this.meetingCollection.getByKey(SIP_URI, targetDest);
-        }
+          // Attempt to collect the meeting if it exists.
+          if (!meeting) {
+            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, useRandomDelayForInfo)
-            .then((createdMeeting: any) => {
+          // Validate if a meeting was found.
+          if (!meeting) {
+            // Create a meeting based on the normalized destination and type.
+            return this.createMeeting(
+              targetDest,
+              type,
+              useRandomDelayForInfo,
+              infoExtraParams
+            ).then((createdMeeting: any) => {
               // If the meeting was successfully created.
               if (createdMeeting && createdMeeting.on) {
                 // Create a destruction event for the meeting.
@@ -841,10 +1081,9 @@ export default class Meetings extends WebexPlugin {
                       correlationId: createdMeeting.correlationId,
                       feedbackId: createdMeeting.correlationId,
                       locusId: createdMeeting.locusId,
-                      meetingId: createdMeeting.locusInfo?.info?.webExMeetingId
+                      meetingId: createdMeeting.locusInfo?.info?.webExMeetingId,
                     }).then(() => this.destroy(createdMeeting, payload.reason));
-                  }
-                  else {
+                  } else {
                     this.destroy(createdMeeting, payload.reason);
                   }
                 });
@@ -857,34 +1096,42 @@ export default class Meetings extends WebexPlugin {
                       correlationId: meetingInstance.correlationId,
                       feedbackId: meetingInstance.correlationId,
                       locusId: meetingInstance.locusId,
-                      meetingId: meetingInstance.locusInfo?.info?.webExMeetingId
+                      meetingId: meetingInstance.locusInfo?.info?.webExMeetingId,
                     });
                   }
                 });
-              }
-              else {
-                LoggerProxy.logger.error(`Meetings:index#create --> ERROR, meeting does not have on method, will not be destroyed, meeting cleanup impossible for meeting: ${meeting}`);
+              } else {
+                LoggerProxy.logger.error(
+                  `Meetings:index#create --> ERROR, meeting does not have on method, will not be destroyed, meeting cleanup impossible for meeting: ${meeting}`
+                );
               }
 
               // Return the newly created meeting.
               return Promise.resolve(createdMeeting);
             });
-        }
+          }
 
-        // Return the existing meeting.
-        return Promise.resolve(meeting);
-      });
+          // Return the existing meeting.
+          return Promise.resolve(meeting);
+        })
+    );
   }
 
   /**
-     * @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
-     */
-  private async createMeeting(destination: any, type: string = null, useRandomDelayForInfo: boolean = false) {
+   * @param {String} destination see create()
+   * @param {String} type see create()
+   * @param {Boolean} useRandomDelayForInfo whether a random delay should be added to fetching meeting info
+   * @param {Object} infoExtraParams extra parameters to be provided when fetching meeting info
+   * @returns {Promise} a new meeting instance complete with meeting info and destination
+   * @private
+   * @memberof Meetings
+   */
+  private async createMeeting(
+    destination: any,
+    type: string = null,
+    useRandomDelayForInfo = false,
+    infoExtraParams = {}
+  ) {
     const meeting = new Meeting(
       {
         // @ts-ignore
@@ -900,7 +1147,7 @@ export default class Meetings extends WebexPlugin {
       },
       {
         // @ts-ignore
-        parent: this.webex
+        parent: this.webex,
       }
     );
 
@@ -918,7 +1165,10 @@ export default class Meetings extends WebexPlugin {
         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);
+        const maxWaitingTime = Math.max(
+          Math.min(timeToStart, MAX_RANDOM_DELAY_FOR_MEETING_INFO),
+          0
+        );
 
         waitingTime = Math.round(Math.random() * maxWaitingTime);
       }
@@ -927,22 +1177,32 @@ export default class Meetings extends WebexPlugin {
       const {enableUnifiedMeetings} = this.config.experimental;
 
       if (enableUnifiedMeetings && !isMeetingActive && useRandomDelayForInfo && waitingTime > 0) {
-        meeting.fetchMeetingInfoTimeoutId = setTimeout(() => meeting.fetchMeetingInfo({}), waitingTime);
+        meeting.fetchMeetingInfoTimeoutId = setTimeout(
+          () => meeting.fetchMeetingInfo({extraParams: infoExtraParams}),
+          waitingTime
+        );
         meeting.parseMeetingInfo(undefined, destination);
+      } else {
+        await meeting.fetchMeetingInfo({extraParams: infoExtraParams});
       }
-      else {
-        await meeting.fetchMeetingInfo({});
-      }
-    }
-    catch (err) {
-      if (!(err instanceof CaptchaError) && !(err instanceof PasswordError)) {
+    } catch (err) {
+      if (
+        !(err instanceof CaptchaError) &&
+        !(err instanceof PasswordError) &&
+        !(err instanceof PermissionError)
+      ) {
         // 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.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.`);
-    }
-    finally {
+      LoggerProxy.logger.debug(
+        `Meetings:index#createMeeting --> Debug ${err} fetching /meetingInfo for creation.`
+      );
+    } finally {
       // For type LOCUS_ID we need to parse the locus object to get the information
       // about the caller and callee
       // Meeting Added event will be created in `handleLocusEvent`
@@ -960,12 +1220,12 @@ export default class Meetings extends WebexPlugin {
           this,
           {
             file: 'meetings',
-            function: 'createMeeting'
+            function: 'createMeeting',
           },
           EVENT_TRIGGERS.MEETING_ADDED,
           {
             meeting,
-            type: meetingAddedType
+            type: meetingAddedType,
           }
         );
       }
@@ -993,26 +1253,26 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * get a specifc meeting given it's type matched to the value, i.e., locus url
-     * @param {String} type
-     * @param {Object} value
-     * @returns {Meeting}
-     * @public
-     * @memberof Meetings
-     */
+   * get a specifc meeting given it's type matched to the value, i.e., locus url
+   * @param {String} type
+   * @param {Object} value
+   * @returns {Meeting}
+   * @public
+   * @memberof Meetings
+   */
   public getMeetingByType(type: string, value: object) {
     return this.meetingCollection.getByKey(type, value);
   }
 
   /**
-     * Get all meetings.
-     * @param {object} options
-     * @param {object} options.startDate - get meetings after this start date
-     * @param {object} options.endDate - get meetings before this end date
-     * @returns {Object} All currently active meetings.
-     * @public
-     * @memberof Meetings
-     */
+   * Get all meetings.
+   * @param {object} options
+   * @param {object} options.startDate - get meetings after this start date
+   * @param {object} options.endDate - get meetings before this end date
+   * @returns {Object} All currently active meetings.
+   * @public
+   * @memberof Meetings
+   */
   public getAllMeetings(
     options: {
       startDate: object;
@@ -1025,57 +1285,132 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-     * syncs all the meeting from server
-     * @returns {undefined}
-     * @public
-     * @memberof Meetings
-     */
+   * syncs all the meeting from server
+   * @returns {undefined}
+   * @public
+   * @memberof Meetings
+   */
   public syncMeetings() {
-    return this.request.getActiveMeetings().then((locusArray) => {
-      const activeLocusUrl = [];
-
-      if (locusArray?.loci && locusArray.loci.length > 0) {
-        locusArray.loci.forEach((locus) => {
-          activeLocusUrl.push(locus.url);
-          this.handleLocusEvent({
-            locus,
-            locusUrl: locus.url
+    return this.request
+      .getActiveMeetings()
+      .then((locusArray) => {
+        const activeLocusUrl = [];
+
+        if (locusArray?.loci && locusArray.loci.length > 0) {
+          const lociToUpdate = this.sortLocusArrayToUpdate(locusArray.loci);
+          lociToUpdate.forEach((locus) => {
+            activeLocusUrl.push(locus.url);
+            this.handleLocusEvent({
+              locus,
+              locusUrl: locus.url,
+            });
           });
-        });
-      }
-      const meetingsCollection = this.meetingCollection.getAll();
-
-      if (Object.keys(meetingsCollection).length > 0) {
-        // Some time the mercury event is missed after mercury reconnect
-        // if sync returns no locus then clear all the meetings
-        for (const meeting of Object.values(meetingsCollection)) {
-          // @ts-ignore
-          if (!activeLocusUrl.includes(meeting.locusUrl)) {
-            // destroy function also uploads logs
+        }
+        const meetingsCollection = this.meetingCollection.getAll();
+
+        if (Object.keys(meetingsCollection).length > 0) {
+          // Some time the mercury event is missed after mercury reconnect
+          // if sync returns no locus then clear all the meetings
+          for (const meeting of Object.values(meetingsCollection)) {
             // @ts-ignore
-            this.destroy(meeting, MEETING_REMOVED_REASON.NO_MEETINGS_TO_SYNC);
+            if (!activeLocusUrl.includes(meeting.locusUrl)) {
+              // destroy function also uploads logs
+              // @ts-ignore
+              this.destroy(meeting, MEETING_REMOVED_REASON.NO_MEETINGS_TO_SYNC);
+            }
           }
         }
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error(
+          `Meetings:index#syncMeetings --> failed to sync meetings, ${error}`
+        );
+        throw new Error(error);
+      });
+  }
+
+  /**
+   * sort out locus array for initial creating
+   * @param {Array} loci original locus array
+   * @returns {undefined}
+   * @public
+   * @memberof Meetings
+   */
+  sortLocusArrayToUpdate(loci: any[]) {
+    const mainLoci = loci.filter((locus) => !MeetingsUtil.isBreakoutLocusDTO(locus));
+    const breakoutLoci = loci.filter((locus) => MeetingsUtil.isValidBreakoutLocus(locus));
+    this.breakoutLocusForHandleLater = [];
+    const lociToUpdate = [...mainLoci];
+    breakoutLoci.forEach((breakoutLocus) => {
+      const associateMainLocus = mainLoci.find(
+        (mainLocus) => mainLocus.controls?.breakout?.url === breakoutLocus.controls?.breakout?.url
+      );
+      const existCorrespondingMeeting = this.getCorrespondingMeetingByLocus({
+        locus: breakoutLocus,
+        locusUrl: breakoutLocus.url,
+      });
+
+      if (associateMainLocus && !existCorrespondingMeeting) {
+        // if exists both main session and breakout session locus of the same non-exist meeting, handle main locus first,
+        // after meeting create with main locus, then handle the associate breakout locus.
+        // if only handle breakout locus, will miss some date
+        this.breakoutLocusForHandleLater.push(breakoutLocus);
+      } else {
+        lociToUpdate.push(breakoutLocus);
       }
     });
+
+    return lociToUpdate;
   }
 
   /**
-     * Get all scheduled meetings.
-     * @param {object} options
-     * @param {object} options.startDate - get meetings after this start date
-     * @param {object} options.endDate - get meetings before this end date
-     * @returns {Object} All scheduled meetings.
-     * @memberof Meetings
-     */
+   * check breakout locus which waiting for main locus's meeting to be created, then handle the breakout locus
+   * @param {Object} newCreatedLocus the locus which just create meeting object of it
+   * @returns {undefined}
+   * @public
+   * @memberof Meetings
+   */
+  checkHandleBreakoutLocus(newCreatedLocus) {
+    if (
+      !newCreatedLocus ||
+      !this.breakoutLocusForHandleLater ||
+      !this.breakoutLocusForHandleLater.length
+    ) {
+      return;
+    }
+    if (MeetingsUtil.isBreakoutLocusDTO(newCreatedLocus)) {
+      return;
+    }
+    const existIndex = this.breakoutLocusForHandleLater.findIndex(
+      (breakoutLocus) =>
+        breakoutLocus.controls?.breakout?.url === newCreatedLocus.controls?.breakout?.url
+    );
+
+    if (existIndex < 0) {
+      return;
+    }
+
+    const associateBreakoutLocus = this.breakoutLocusForHandleLater[existIndex];
+    this.handleLocusEvent({locus: associateBreakoutLocus, locusUrl: associateBreakoutLocus.url});
+    this.breakoutLocusForHandleLater.splice(existIndex, 1);
+  }
+
+  /**
+   * Get all scheduled meetings.
+   * @param {object} options
+   * @param {object} options.startDate - get meetings after this start date
+   * @param {object} options.endDate - get meetings before this end date
+   * @returns {Object} All scheduled meetings.
+   * @memberof Meetings
+   */
   getScheduledMeetings() {
     return this.meetingCollection.getAll({scheduled: true});
   }
 
   /**
-     * Get the logger instance for plugin-meetings
-     * @returns {Logger}
-     */
+   * Get the logger instance for plugin-meetings
+   * @returns {Logger}
+   */
   getLogger() {
     return LoggerProxy.get();
   }