@webex/plugin-meetings 3.0.0-beta.83 → 3.0.0-beta.85

package/src/breakouts/index.ts

@@ -49,6 +49,7 @@ const Breakouts = WebexPlugin.extend({
 
   derived: {
     isInMainSession: {
+      cache: false,
       deps: ['sessionType'],
       /**
        * Returns true if the user is in the main session
@@ -59,6 +60,7 @@ const Breakouts = WebexPlugin.extend({
       },
     },
     isActiveBreakout: {
+      cache: false, // fix issue: sometimes the derived will not change even if the deps changed
       deps: ['sessionType', 'status'],
       /**
        * Returns true if the breakout status is active
@@ -72,6 +74,7 @@ const Breakouts = WebexPlugin.extend({
       },
     },
     breakoutGroupId: {
+      cache: false,
       deps: ['groups'],
       /**
        * Returns the actived group id
@@ -399,13 +402,14 @@ const Breakouts = WebexPlugin.extend({
 
   /**
    * Create new breakout sessions
-   * @param {object} sessions -- breakout session group
+   * @param {object} params -- breakout session group
    * @returns {Promise}
    */
-  async create(sessions) {
+  async create(params) {
+    const payload = {...params};
     const body = {
       ...(this.editLock && !!this.editLock.token ? {editlock: {token: this.editLock.token}} : {}),
-      ...{groups: [{sessions}]},
+      ...{groups: [payload]},
     };
     // @ts-ignore
     const breakInfo = await this.webex

package/src/constants.ts

@@ -581,6 +581,7 @@ export const LOCUSINFO = {
     CONTROLS_MEETING_BREAKOUT_UPDATED: 'CONTROLS_MEETING_BREAKOUT_UPDATED',
     CONTROLS_MEETING_CONTAINER_UPDATED: 'CONTROLS_MEETING_CONTAINER_UPDATED',
     CONTROLS_ENTRY_EXIT_TONE_UPDATED: 'CONTROLS_ENTRY_EXIT_TONE_UPDATED',
+    CONTROLS_JOIN_BREAKOUT_FROM_MAIN: 'CONTROLS_JOIN_BREAKOUT_FROM_MAIN',
     SELF_UNADMITTED_GUEST: 'SELF_UNADMITTED_GUEST',
     SELF_ADMITTED_GUEST: 'SELF_ADMITTED_GUEST',
     SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED: 'SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED',

package/src/locus-info/controlsUtils.ts

@@ -1,4 +1,5 @@
 import {isEqual} from 'lodash';
+import {BREAKOUTS} from '../constants';
 
 const ControlsUtils: any = {};
 
@@ -138,4 +139,31 @@ ControlsUtils.isNeedReplaceMembers = (oldControls: any, controls: any) => {
   );
 };
 
+/**
+ * determine the switch status between breakout session and main session.
+ * @param {LocusControls} oldControls
+ * @param {LocusControls} controls
+ * @returns {Object}
+ */
+ControlsUtils.getSessionSwitchStatus = (oldControls: any, controls: any) => {
+  const status = {isReturnToMain: false, isJoinToBreakout: false};
+  // no breakout case
+  if (!oldControls?.breakout || !controls?.breakout) {
+    return status;
+  }
+
+  status.isReturnToMain =
+    oldControls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT &&
+    controls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.MAIN;
+  status.isJoinToBreakout =
+    oldControls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.MAIN &&
+    controls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT;
+
+  return status;
+};
+
+ControlsUtils.isMainSessionDTO = (locus: any) => {
+  return locus?.controls?.breakout?.sessionType !== BREAKOUTS.SESSION_TYPES.BREAKOUT;
+};
+
 export default ControlsUtils;

package/src/locus-info/index.ts

@@ -1,4 +1,4 @@
-import {isEqual} from 'lodash';
+import {isArray, isEqual, mergeWith, cloneDeep} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsScope from '../common/events/events-scope';
@@ -64,7 +64,7 @@ export default class LocusInfo extends EventsScope {
   replace: any;
   url: any;
   services: any;
-
+  mainSessionLocusCache: any;
   /**
    * Constructor
    * @param {boolean} updateMeeting true if the meeting should be updated
@@ -180,6 +180,7 @@ export default class LocusInfo extends EventsScope {
      */
     this.deltaParticipants = [];
 
+    this.updateLocusCache(locus);
     // above section only updates the locusInfo object
     // The below section makes sure it updates the locusInfo as well as updates the meeting object
     this.updateParticipants(locus.participants);
@@ -203,6 +204,7 @@ export default class LocusInfo extends EventsScope {
    * @memberof LocusInfo
    */
   initialSetup(locus: object) {
+    this.updateLocusCache(locus);
     this.onFullLocus(locus);
 
     // Change it to true after it receives it first locus object
@@ -218,7 +220,7 @@ export default class LocusInfo extends EventsScope {
   parse(meeting: any, data: any) {
     // eslint-disable-next-line @typescript-eslint/no-shadow
     const {eventType} = data;
-
+    const locus = this.getTheLocusToUpdate(data.locus);
     LoggerProxy.logger.info(`Locus-info:index#parse --> received locus data: ${eventType}`);
 
     switch (eventType) {
@@ -236,16 +238,16 @@ export default class LocusInfo extends EventsScope {
       case LOCUSEVENT.PARTICIPANT_DECLINED:
       case LOCUSEVENT.FLOOR_GRANTED:
       case LOCUSEVENT.FLOOR_RELEASED:
-        this.onFullLocus(data.locus, eventType);
+        this.onFullLocus(locus, eventType);
         break;
       case LOCUSEVENT.DIFFERENCE:
-        this.handleLocusDelta(data.locus, meeting);
+        this.handleLocusDelta(locus, meeting);
         break;
 
       default:
         // Why will there be a event with no eventType ????
         // we may not need this, we can get full locus
-        this.handleLocusDelta(data.locus, meeting);
+        this.handleLocusDelta(locus, meeting);
     }
   }
 
@@ -1395,4 +1397,106 @@ export default class LocusInfo extends EventsScope {
       this.identities = identities;
     }
   }
+
+  /**
+   * check the locus is main session's one or not, if is main session's, update main session cache
+   * @param {Object} locus
+   * @returns {undefined}
+   * @memberof LocusInfo
+   */
+  updateLocusCache(locus: any) {
+    const isMainSessionDTO = ControlsUtils.isMainSessionDTO(locus);
+    if (isMainSessionDTO) {
+      this.updateMainSessionLocusCache(locus);
+    }
+  }
+
+  /**
+   * if return from breakout to main session, need to use cached main session DTO since locus won't send the full locus (participants)
+   * if join breakout from main session, need to query main locus url (if response with 403 means no privilege, need to clear the cache)
+   * @param {Object} newLocus
+   * @returns {Object}
+   * @memberof LocusInfo
+   */
+  getTheLocusToUpdate(newLocus: any) {
+    const switchStatus = ControlsUtils.getSessionSwitchStatus(this.controls, newLocus.controls);
+    if (switchStatus.isReturnToMain && this.mainSessionLocusCache) {
+      return cloneDeep(this.mainSessionLocusCache);
+    }
+    if (switchStatus.isJoinToBreakout) {
+      this.emitScoped(
+        {
+          file: 'locus-info',
+          function: 'updateControls',
+        },
+        LOCUSINFO.EVENTS.CONTROLS_JOIN_BREAKOUT_FROM_MAIN,
+        {
+          mainLocusUrl: this.url,
+        }
+      );
+    }
+
+    return newLocus;
+  }
+
+  /**
+   * merge participants by participant id
+   * @param {Array} participants
+   * @param {Array} sourceParticipants
+   * @returns {Array} merged participants
+   * @memberof LocusInfo
+   */
+  // eslint-disable-next-line class-methods-use-this
+  mergeParticipants(participants, sourceParticipants) {
+    if (!sourceParticipants || !sourceParticipants.length) return participants;
+    if (!participants || !participants.length) {
+      return sourceParticipants;
+    }
+    sourceParticipants.forEach((participant) => {
+      const existIndex = participants.findIndex((p) => p.id === participant.id);
+      if (existIndex > -1) {
+        participants.splice(existIndex, 1, participant);
+      } else {
+        participants.push(participant);
+      }
+    });
+
+    return participants;
+  }
+
+  /**
+   * need cache main sessions' participants since locus will not send the full list when cohost/host leave breakout
+   * @param {Object} mainLocus
+   * @returns {undefined}
+   * @memberof LocusInfo
+   */
+  updateMainSessionLocusCache(mainLocus: any) {
+    if (!mainLocus) {
+      return;
+    }
+    const locusClone = cloneDeep(mainLocus);
+    if (this.mainSessionLocusCache) {
+      // eslint-disable-next-line consistent-return
+      mergeWith(this.mainSessionLocusCache, locusClone, (objValue, srcValue, key) => {
+        if (isArray(objValue)) {
+          if (key === 'participants') {
+            return this.mergeParticipants(objValue, srcValue);
+          }
+
+          return srcValue; // just replace the old ones
+        }
+      });
+    } else {
+      this.mainSessionLocusCache = locusClone;
+    }
+  }
+
+  /**
+   * clear main session cache
+   * @returns {undefined}
+   * @memberof LocusInfo
+   */
+  clearMainSessionLocusCache() {
+    this.mainSessionLocusCache = null;
+  }
 }

package/src/meeting/index.ts

@@ -1991,6 +1991,16 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     });
 
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_JOIN_BREAKOUT_FROM_MAIN, ({mainLocusUrl}) => {
+      this.meetingRequest.getLocusStatusByUrl(mainLocusUrl).catch((error) => {
+        // clear main session cache when attendee join into breakout and forbidden to get locus from main locus url,
+        // which means main session is not active for the attendee
+        if (error?.statusCode === 403) {
+          this.locusInfo.clearMainSessionLocusCache();
+        }
+      });
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_ENTRY_EXIT_TONE_UPDATED, ({entryExitTone}) => {
       Trigger.trigger(
         this,

package/src/meeting/request.ts

@@ -865,4 +865,12 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       },
     });
   }
+
+  getLocusStatusByUrl(locusUrl: string) {
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: locusUrl,
+    });
+  }
 }

package/src/meetings/index.ts

@@ -246,8 +246,14 @@ export default class Meetings extends WebexPlugin {
 
     const isSelfJoined = newLocus?.self?.state === _JOINED_;
     const isSelfMoved = newLocus?.self?.state === _LEFT_ && newLocus?.self?.reason === _MOVED_;
-    const deviceFromNewLocus = MeetingsUtil.getThisDevice(newLocus);
-    const isNewLocusJoinThisDevice = MeetingsUtil.joinedOnThisDevice(meeting, newLocus);
+    // @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;
@@ -305,8 +311,7 @@ export default class Meetings extends WebexPlugin {
    */
   private isNeedHandleLocusDTO(meeting: any, newLocus: any) {
     if (newLocus) {
-      const isNewLocusAsBreakout =
-        newLocus.controls?.breakout?.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT;
+      const isNewLocusAsBreakout = MeetingsUtil.isBreakoutLocusDTO(newLocus);
       const isSelfMoved = newLocus?.self?.state === _LEFT_ && newLocus?.self?.reason === _MOVED_;
       if (!meeting) {
         if (isNewLocusAsBreakout) {
@@ -375,6 +380,9 @@ export default class Meetings extends WebexPlugin {
       );
     }
 
+    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`

package/src/meetings/util.ts

@@ -1,16 +1,17 @@
 /* globals window */
 
 import {
-  _LOCUS_ID_,
-  _INCOMING_,
   _CREATED_,
-  LOCUSEVENT,
+  _INCOMING_,
+  _JOINED_,
+  _LEFT_,
+  _LOCUS_ID_,
+  _MOVED_,
+  BREAKOUTS,
   CORRELATION_ID,
   EVENT_TRIGGERS,
+  LOCUSEVENT,
   ROAP,
-  _LEFT_,
-  _MOVED_,
-  _JOINED_,
 } from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 import Trigger from '../common/events/trigger-proxy';
@@ -228,13 +229,12 @@ MeetingsUtil.checkH264Support = async function checkH264Support(options: {
 /**
  * get device from locus data
  * @param {Object} newLocus new locus data
+ * @param {String} deviceUrl current device url
  * @returns {Object}
  */
-MeetingsUtil.getThisDevice = (newLocus: any) => {
+MeetingsUtil.getThisDevice = (newLocus: any, deviceUrl: string) => {
   if (newLocus?.self?.devices?.length > 0) {
-    const [thisDevice] = newLocus.self.devices;
-
-    return thisDevice;
+    return newLocus.self.devices.find((device) => device.url === deviceUrl);
   }
 
   return null;
@@ -244,10 +244,11 @@ MeetingsUtil.getThisDevice = (newLocus: any) => {
  * get self device joined status from locus data
  * @param {Object} meeting current meeting data
  * @param {Object} newLocus new locus data
+ * @param {String} deviceUrl current device url
  * @returns {Object}
  */
-MeetingsUtil.joinedOnThisDevice = (meeting: any, newLocus: any) => {
-  const thisDevice = MeetingsUtil.getThisDevice(newLocus);
+MeetingsUtil.joinedOnThisDevice = (meeting: any, newLocus: any, deviceUrl: string) => {
+  const thisDevice = MeetingsUtil.getThisDevice(newLocus, deviceUrl);
   if (thisDevice) {
     if (!thisDevice.correlationId || meeting?.correlationId === thisDevice.correlationId) {
       return (
@@ -260,4 +261,14 @@ MeetingsUtil.joinedOnThisDevice = (meeting: any, newLocus: any) => {
   return false;
 };
 
+/**
+ * check the new locus is breakout session's one or not
+ * @param {Object} newLocus new locus data
+ * @returns {boolean}
+ * @private
+ * @memberof Meetings
+ */
+MeetingsUtil.isBreakoutLocusDTO = (newLocus: any) => {
+  return newLocus?.controls?.breakout?.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT;
+};
 export default MeetingsUtil;

package/src/roap/index.ts

@@ -199,19 +199,23 @@ export default class Roap extends StatelessWebexPlugin {
     // When reconnecting, it's important that the first roap message being sent out has empty media id.
     // Normally this is the roap offer, but when TURN discovery is enabled,
     // then this is the TURN discovery request message
-    const sendEmptyMediaId = reconnect && !meeting.config.experimental.enableTurnDiscovery;
+    return this.turnDiscovery
+      .isSkipped(meeting)
+      .then((isTurnDiscoverySkipped) => {
+        const sendEmptyMediaId = reconnect && isTurnDiscoverySkipped;
 
-    return this.roapRequest
-      .sendRoap({
-        roapMessage,
-        correlationId: meeting.correlationId,
-        locusSelfUrl: meeting.selfUrl,
-        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-        audioMuted: meeting.audio?.isLocallyMuted(),
-        videoMuted: meeting.video?.isLocallyMuted(),
-        meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
+        return this.roapRequest.sendRoap({
+          roapMessage,
+          correlationId: meeting.correlationId,
+          locusSelfUrl: meeting.selfUrl,
+          mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
+          audioMuted: meeting.audio?.isLocallyMuted(),
+          videoMuted: meeting.video?.isLocallyMuted(),
+          meetingId: meeting.id,
+          preferTranscoding: !meeting.isMultistream,
+        });
       })
+
       .then(({locus, mediaConnections}) => {
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);

package/src/roap/turnDiscovery.ts

@@ -221,6 +221,48 @@ export default class TurnDiscovery {
     });
   }
 
+  /**
+   * Gets the reason why reachability is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
+   */
+  private async getSkipReason(meeting: Meeting): Promise<string> {
+    // @ts-ignore - fix type
+    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
+
+    if (isAnyClusterReachable) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
+      );
+
+      return 'reachability';
+    }
+
+    // @ts-ignore - fix type
+    if (!meeting.config.experimental.enableTurnDiscovery) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> TURN discovery disabled in config, skipping it'
+      );
+
+      return 'config';
+    }
+
+    return '';
+  }
+
+  /**
+   * Checks if TURN discovery is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
+   */
+  async isSkipped(meeting) {
+    const skipReason = await this.getSkipReason(meeting);
+
+    return !!skipReason;
+  }
+
   /**
    * Retrieves TURN server information from the backend by doing
    * a roap message exchange:
@@ -239,29 +281,15 @@ export default class TurnDiscovery {
    * @returns {Promise}
    */
   async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
-    // @ts-ignore - fix type
-    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
-
-    if (isAnyClusterReachable) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#doTurnDiscovery --> reachability has not failed, skipping TURN discovery'
-      );
+    const turnDiscoverySkippedReason = await this.getSkipReason(meeting);
 
+    if (turnDiscoverySkippedReason) {
       return {
         turnServerInfo: undefined,
-        turnDiscoverySkippedReason: 'reachability',
+        turnDiscoverySkippedReason,
       };
     }
 
-    // @ts-ignore - fix type
-    if (!meeting.config.experimental.enableTurnDiscovery) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it'
-      );
-
-      return {turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'};
-    }
-
     return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
       .then(() => this.waitForTurnDiscoveryResponse())
       .then(() => this.sendRoapOK(meeting))

package/test/unit/spec/breakouts/index.ts

@@ -868,7 +868,7 @@ describe('plugin-meetings', () => {
     describe('create', () => {
       it('response not include groups info', async () => {
         const sessions = [{name: 'session1', anyoneCanJoin: true}];
-        const result = await breakouts.create(sessions);
+        const result = await breakouts.create({sessions});
 
         assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
@@ -890,7 +890,7 @@ describe('plugin-meetings', () => {
           })
         );
 
-        const result = await breakouts.create(sessions);
+        const result = await breakouts.create({sessions});
 
         assert.equal(breakouts.groups[0].id, '455556a4-37cd-4baa-89bc-8730581a1cc0');
       });
@@ -908,7 +908,7 @@ describe('plugin-meetings', () => {
         );
 
         await assert.isRejected(
-          breakouts.create(sessions),
+          breakouts.create({sessions}),
           BreakoutEditLockedError,
           'Edit lock token mismatch'
         );

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

@@ -176,6 +176,52 @@ describe('plugin-meetings', () => {
         const newControls = {breakout: {sessionId: 'sessionId1', groupId: 'groupId'}};
         assert.equal(controlsUtils.isNeedReplaceMembers(oldControls, newControls), false);
       });
-    })
+    });
+
+    describe('getSessionSwitchStatus', () => {
+      it('if no breakout control, return switch status both false', () => {
+        const oldControls = {};
+        const newControls = {};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+          isReturnToMain: false, isJoinToBreakout: false
+        });
+      });
+
+      it('if switch session from breakout to main, return isReturnToMain as true', () => {
+        const oldControls = {breakout: {sessionType: 'BREAKOUT'}};
+        const newControls = {breakout: {sessionType: 'MAIN'}};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+          isReturnToMain: true, isJoinToBreakout: false
+        });
+      });
+
+      it('if switch session from main to breakout, return isJoinToBreakout as true', () => {
+        const oldControls = {breakout: {sessionType: 'MAIN'}};
+        const newControls = {breakout: {sessionType: 'BREAKOUT'}};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+          isReturnToMain: false, isJoinToBreakout: true
+        });
+      });
+    });
+
+    describe('#isMainSessionDTO', () => {
+      it('return false is sessionType is BREAKOUT', () => {
+        const locus = {
+          controls: {breakout: {sessionType: 'BREAKOUT'}}
+        };
+
+        assert.equal(controlsUtils.isMainSessionDTO(locus), false);
+      });
+
+      it('return true is sessionType is not BREAKOUT', () => {
+        const locus = {
+          controls: {breakout: {sessionType: 'MAIN'}}
+        };
+
+        assert.equal(controlsUtils.isMainSessionDTO(locus), true);
+
+        assert.equal(controlsUtils.isMainSessionDTO({}), true);
+      });
+    });
   });
 });