@webex/plugin-meetings 3.0.0-beta.34 → 3.0.0-beta.36

package/src/meeting/request.ts

@@ -23,10 +23,10 @@ import {
   PARTICIPANT,
   PROVISIONAL_TYPE_DIAL_IN,
   PROVISIONAL_TYPE_DIAL_OUT,
+  REACHABILITY,
   SEND_DTMF_ENDPOINT,
   _SLIDES_,
 } from '../constants';
-import {Reaction} from '../reactions/reactions.type';
 import {SendReactionOptions, ToggleReactionsOptions} from './request.type';
 
 /**
@@ -35,6 +35,11 @@ import {SendReactionOptions, ToggleReactionsOptions} from './request.type';
 export default class MeetingRequest extends StatelessWebexPlugin {
   changeVideoLayoutDebounced: any;
 
+  /**
+   * Constructor
+   * @param {Object} attrs
+   * @param {Object} options
+   */
   constructor(attrs: any, options: any) {
     super(attrs, options);
     this.changeVideoLayoutDebounced = debounce(this.changeVideoLayout, 2000, {
@@ -43,6 +48,32 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     });
   }
 
+  /**
+   * Returns joinCookie from boundedStorage if present.
+   * @returns {Object} joinCookie
+   */
+  private getJoinCookie = async () => {
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
+
+    if (joinCookieRaw) {
+      try {
+        const joinCookie = JSON.parse(joinCookieRaw);
+        if (joinCookie) {
+          return joinCookie;
+        }
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+        );
+      }
+    }
+
+    return null;
+  };
+
   /**
    * Make a network request to join a meeting
    * @param {Object} options
@@ -99,6 +130,8 @@ export default class MeetingRequest extends StatelessWebexPlugin {
 
     let url = '';
 
+    const joinCookie = await this.getJoinCookie();
+
     const body: any = {
       asResourceOccupant,
       device: {
@@ -115,6 +148,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       supportsNativeLobby: 1,
       clientMediaPreferences: {
         preferTranscoding: preferTranscoding ?? true,
+        joinCookie,
       },
     };
 

package/src/meeting/util.ts

@@ -1,4 +1,5 @@
 import {isEmpty} from 'lodash';
+import {LocalCameraTrack, LocalMicrophoneTrack} from '@webex/internal-media-core';
 
 import {MeetingNotActiveError, UserNotJoinedError} from '../common/errors/webex-errors';
 import Metrics from '../metrics';
@@ -390,11 +391,11 @@ MeetingUtil.unlockMeeting = (actions, request, locusUrl) => {
   return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
 };
 
-MeetingUtil.handleAudioLogging = (audioTrack) => {
+MeetingUtil.handleAudioLogging = (audioTrack: LocalMicrophoneTrack | null) => {
   const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
 
   if (audioTrack) {
-    const settings = audioTrack.getSettings();
+    const settings = audioTrack.underlyingTrack.getSettings();
     const {deviceId} = settings;
 
     LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
@@ -402,11 +403,11 @@ MeetingUtil.handleAudioLogging = (audioTrack) => {
   }
 };
 
-MeetingUtil.handleVideoLogging = (videoTrack) => {
+MeetingUtil.handleVideoLogging = (videoTrack: LocalCameraTrack | null) => {
   const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
 
   if (videoTrack) {
-    const settings = videoTrack.getSettings();
+    const settings = videoTrack.underlyingTrack.getSettings();
     const {deviceId} = settings;
 
     LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);

package/src/metrics/constants.ts

@@ -40,10 +40,6 @@ const BEHAVIORAL_METRICS = {
   INVALID_ICE_CANDIDATE: 'js_sdk_invalid_ice_candidate',
   UPLOAD_LOGS_FAILURE: 'js_sdk_upload_logs_failure',
   RECEIVE_TRANSCRIPTION_FAILURE: 'js_sdk_receive_transcription_failure',
-  ENABLE_BNR_SUCCESS: 'js_sdk_enable_bnr_success',
-  ENABLE_BNR_FAILURE: 'js_sdk_enable_bnr_failure',
-  DISABLE_BNR_SUCCESS: 'js_sdk_disable_bnr_success',
-  DISABLE_BNR_FAILURE: 'js_sdk_disable_bnr_failure',
   FETCH_MEETING_INFO_V1_SUCCESS: 'js_sdk_fetch_meeting_info_v1_success',
   FETCH_MEETING_INFO_V1_FAILURE: 'js_sdk_fetch_meeting_info_v1_failure',
   ADHOC_MEETING_SUCCESS: 'js_sdk_adhoc_meeting_success',

package/src/reachability/index.ts

@@ -63,11 +63,13 @@ export default class Reachability {
 
     // Remove stored reachability results to ensure no stale data
     // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorage);
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
 
     // Fetch clusters and measure latency
     try {
-      const clusters = await this.reachabilityRequest.getClusters();
+      const {clusters, joinCookie} = await this.reachabilityRequest.getClusters();
 
       // Perform Reachability Check
       const results = await this.performReachabilityCheck(clusters);
@@ -75,9 +77,15 @@ export default class Reachability {
       // @ts-ignore
       await this.webex.boundedStorage.put(
         this.namespace,
-        REACHABILITY.localStorage,
+        REACHABILITY.localStorageResult,
         JSON.stringify(results)
       );
+      // @ts-ignore
+      await this.webex.boundedStorage.put(
+        this.namespace,
+        REACHABILITY.localStorageJoinCookie,
+        JSON.stringify(joinCookie)
+      );
 
       LoggerProxy.logger.log(
         'Reachability:index#gatherReachability --> Reachability checks completed'
@@ -103,7 +111,7 @@ export default class Reachability {
     let reachable = false;
     // @ts-ignore
     const reachabilityData = await this.webex.boundedStorage
-      .get(this.namespace, REACHABILITY.localStorage)
+      .get(this.namespace, REACHABILITY.localStorageResult)
       .catch(() => {});
 
     if (reachabilityData) {

package/src/reachability/request.ts

@@ -28,21 +28,23 @@ class ReachabilityRequest {
   }
 
   /**
-   * gets the cluster information
+   * Gets the cluster information
    *
-   * @param {boolean} includeVideoMesh whether to include the video mesh clusters in the result or not
    * @returns {Promise}
    */
-  getClusters = (): Promise<ClusterList> =>
+  getClusters = (): Promise<{clusters: ClusterList; joinCookie: any}> =>
     this.webex
       .request({
         method: HTTP_VERBS.GET,
         shouldRefreshAccessToken: false,
         api: API.CALLIOPEDISCOVERY,
         resource: RESOURCE.CLUSTERS,
+        qs: {
+          JCSupport: 1,
+        },
       })
       .then((res) => {
-        const {clusters} = res.body;
+        const {clusters, joinCookie} = res.body;
 
         Object.keys(clusters).forEach((key) => {
           clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
@@ -52,7 +54,10 @@ class ReachabilityRequest {
           `Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`
         );
 
-        return clusters;
+        return {
+          clusters,
+          joinCookie,
+        };
       });
 
   /**

package/src/reconnection-manager/index.ts

@@ -476,7 +476,7 @@ export default class ReconnectionManager {
 
       if (wasSharing) {
         // Stop the share streams if user tried to rejoin
-        Media.stopTracks(this.meeting.mediaProperties.shareTrack);
+        this.meeting.setLocalShareTrack(null);
         this.meeting.isSharing = false;
         if (this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
           this.meeting.shareStatus = SHARE_STATUS.NO_SHARE;

package/src/roap/request.ts

@@ -12,14 +12,16 @@ import {eventType} from '../metrics/config';
  */
 export default class RoapRequest extends StatelessWebexPlugin {
   /**
-   * Joins a meeting via ROAP
+   * Returns reachability data.
    * @param {Object} localSdp
-   * @returns {Promise} returns a promise that resolves/rejects whatever the request does
+   * @returns {Object}
    */
-  async attachRechabilityData(localSdp) {
+  async attachReachabilityData(localSdp) {
+    let joinCookie;
+
     // @ts-ignore
     const reachabilityData = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorage)
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageResult)
       .catch(() => {});
 
     if (reachabilityData) {
@@ -37,7 +39,22 @@ export default class RoapRequest extends StatelessWebexPlugin {
       }
     }
 
-    return localSdp;
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
+
+    if (joinCookieRaw) {
+      try {
+        joinCookie = JSON.parse(joinCookieRaw);
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+        );
+      }
+    }
+
+    return {localSdp, joinCookie};
   }
 
   /**
@@ -53,7 +70,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {Boolean} options.preferTranscoding
    * @returns {Promise} returns the response/failure of the request
    */
-  sendRoap(options: {
+  async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
@@ -69,6 +86,14 @@ export default class RoapRequest extends StatelessWebexPlugin {
       LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
     }
 
+    const {localSdp: localSdpWithReachabilityData, joinCookie} = await this.attachReachabilityData({
+      roapMessage,
+      // eslint-disable-next-line no-warning-comments
+      // TODO: check whats the need for video and audiomute
+      audioMuted: !!options.audioMuted,
+      videoMuted: !!options.videoMuted,
+    });
+
     const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
     // @ts-ignore
     const deviceUrl = this.webex.internal.device.url;
@@ -79,79 +104,69 @@ export default class RoapRequest extends StatelessWebexPlugin {
 
     Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
 
-    return this.attachRechabilityData({
-      roapMessage,
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check whats the need for video and audiomute
-      audioMuted: !!options.audioMuted,
-      videoMuted: !!options.videoMuted,
-    }).then((sdpWithReachability) => {
-      // @ts-ignore
-      return this.webex
-        .request({
-          uri: mediaUrl,
-          method: HTTP_VERBS.PUT,
-          body: {
-            device: {
-              url: deviceUrl,
-              // @ts-ignore
-              deviceType: this.config.meetings.deviceType,
-            },
-            correlationId,
-            localMedias: [
-              {
-                localSdp: JSON.stringify(sdpWithReachability),
-                mediaId: options.mediaId,
-              },
-            ],
-            clientMediaPreferences: {
-              preferTranscoding: options.preferTranscoding ?? true,
-            },
+    // @ts-ignore
+    return this.request({
+      uri: mediaUrl,
+      method: HTTP_VERBS.PUT,
+      body: {
+        device: {
+          url: deviceUrl,
+          // @ts-ignore
+          deviceType: this.config.meetings.deviceType,
+        },
+        correlationId,
+        localMedias: [
+          {
+            localSdp: JSON.stringify(localSdpWithReachabilityData),
+            mediaId: options.mediaId,
           },
-        })
-        .then((res) => {
-          Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
-          // always it will be the first mediaConnection Object
-          const mediaConnections =
-            res.body.mediaConnections &&
-            res.body.mediaConnections.length > 0 &&
-            res.body.mediaConnections[0];
-
-          LoggerProxy.logger.debug(
-            `Roap:request#sendRoap --> response:${JSON.stringify(
-              mediaConnections,
-              null,
-              2
-            )}'\n StatusCode:'${res.statusCode}`
-          );
-          const {locus} = res.body;
-
-          locus.roapSeq = options.roapMessage.seq;
-
-          return {
-            locus,
-            ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
-          };
-        })
-        .catch((err) => {
-          Metrics.postEvent({
-            event: eventType.MEDIA_RESPONSE,
-            meetingId,
-            data: {error: Metrics.parseLocusError(err, true)},
-          });
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`
-          );
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
-              roapMessage,
-              null,
-              2
-            )} + '\\n mediaId:'${options.mediaId}`
-          );
-          throw err;
+        ],
+        clientMediaPreferences: {
+          preferTranscoding: options.preferTranscoding ?? true,
+          joinCookie,
+        },
+      },
+    })
+      .then((res) => {
+        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
+
+        // always it will be the first mediaConnection Object
+        const mediaConnections =
+          res.body.mediaConnections &&
+          res.body.mediaConnections.length > 0 &&
+          res.body.mediaConnections[0];
+
+        LoggerProxy.logger.debug(
+          `Roap:request#sendRoap --> response:${JSON.stringify(
+            mediaConnections,
+            null,
+            2
+          )}'\n StatusCode:'${res.statusCode}`
+        );
+        const {locus} = res.body;
+
+        locus.roapSeq = options.roapMessage.seq;
+
+        return {
+          locus,
+          ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
+        };
+      })
+      .catch((err) => {
+        Metrics.postEvent({
+          event: eventType.MEDIA_RESPONSE,
+          meetingId,
+          data: {error: Metrics.parseLocusError(err, true)},
         });
-    });
+        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
+        LoggerProxy.logger.error(
+          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
+            roapMessage,
+            null,
+            2
+          )} + '\\n mediaId:'${options.mediaId}`
+        );
+        throw err;
+      });
   }
 }

package/test/integration/spec/converged-space-meetings.js

@@ -142,9 +142,9 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: chris.meeting, event: 'media:negotiated'},
         ]);
 
-        const addMediaAlice = testUtils.addMedia(alice, {expectedMediaReadyTypes: ['local']});
-        const addMediaBob = testUtils.addMedia(bob, {expectedMediaReadyTypes: ['local']});
-        const addMediaChris = testUtils.addMedia(chris, {expectedMediaReadyTypes: ['local']});
+        const addMediaAlice = testUtils.addMedia(alice, {multistream: true, expectedMediaReadyTypes: ['local']});
+        const addMediaBob = testUtils.addMedia(bob, {multistream: true, expectedMediaReadyTypes: ['local']});
+        const addMediaChris = testUtils.addMedia(chris, {multistream: true, expectedMediaReadyTypes: ['local']});
 
         await addMediaAlice;
         await addMediaBob;

package/test/integration/spec/journey.js

@@ -605,7 +605,7 @@ skipInNode(describe)('plugin-meetings', () => {
         ]).then(() => {
           // TODO: Re-eanable Safari when screensharing issues have been resolved
           if (!isBrowser('safari')) {
-            assert.equal(alice.meeting.mediaProperties.shareTrack.getConstraints().height, 720);
+            assert.equal(alice.meeting.mediaProperties.shareTrack.underlyingTrack.getConstraints().height, 720);
           }
           assert.equal(alice.meeting.isSharing, true);
           assert.equal(alice.meeting.shareStatus, 'local_share_active');
@@ -646,7 +646,7 @@ skipInNode(describe)('plugin-meetings', () => {
           // TODO: Re-eanable Safari when screensharing issues have been resolved
           if (!isBrowser('safari')) {
             assert.equal(
-              bob.meeting.mediaProperties.shareTrack.getConstraints().height,
+              bob.meeting.mediaProperties.shareTrack.underlyingTrack.getConstraints().height,
               heightResolution
             );
           }
@@ -806,7 +806,7 @@ skipInNode(describe)('plugin-meetings', () => {
           // TODO: Re-eanable Safari when screensharing issues have been resolved
           if (!isBrowser('safari')) {
             assert.equal(
-              bob.meeting.mediaProperties.shareTrack.getConstraints().height,
+              bob.meeting.mediaProperties.shareTrack.underlyingTrack.getConstraints().height,
               heightResolution
             );
           }

package/test/unit/spec/breakouts/edit-lock-error.ts

@@ -0,0 +1,30 @@
+import BreakoutEditLockedError from '@webex/plugin-meetings/src/breakouts/edit-lock-error';
+import {assert, expect} from '@webex/test-helper-chai';
+import {ERROR_DICTIONARY} from '@webex/plugin-meetings/src/constants';
+import {BREAKOUTS} from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings', () => {
+    describe('edit-lock-error', () => {
+        it('check constructor paramter', () => {
+            const result = new BreakoutEditLockedError();
+            assert.equal(result.name, ERROR_DICTIONARY.BREAKOUT_EDIT.NAME);
+            assert.equal(result.sdkMessage, ERROR_DICTIONARY.BREAKOUT_EDIT.MESSAGE);
+            assert.equal(result.code, ERROR_DICTIONARY.BREAKOUT_EDIT.CODE);
+            assert.equal(result.error, null);
+        });
+
+        it('check constructor paramter', () => {
+            const fakeError = {
+                body: {
+                  "errorCode":BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH,
+                  "message":"Edit lock token mismatch"
+                }
+              };
+            const result = new BreakoutEditLockedError('message', fakeError);
+            assert.equal(result.name, ERROR_DICTIONARY.BREAKOUT_EDIT.NAME);
+            assert.equal(result.sdkMessage, ERROR_DICTIONARY.BREAKOUT_EDIT.MESSAGE);
+            assert.equal(result.code, ERROR_DICTIONARY.BREAKOUT_EDIT.CODE);
+            assert.equal(result.error, fakeError);
+        });
+    });
+});

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

@@ -7,7 +7,7 @@ import {BREAKOUTS} from '@webex/plugin-meetings/src/constants';
 import sinon from "sinon";
 import MockWebex from '@webex/test-helper-mock-webex';
 import testUtils from '../../../utils/testUtils';
-
+import BreakoutEditLockedError from "@webex/plugin-meetings/src/breakouts/edit-lock-error";
 
 describe('plugin-meetings', () => {
   describe('Breakouts', () => {
@@ -460,5 +460,96 @@ describe('plugin-meetings', () => {
         assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
     });
+
+    describe('delete', () => {
+      it('makes the request as expected', async () => {
+        webex.request.returns(Promise.resolve({
+          body: {
+            groups: [{
+              id : "455556a4-37cd-4baa-89bc-8730581a1cc0",
+              status : "CLOSE",
+              type : "BREAKOUT",
+            }]
+          }
+        }));
+
+        const result = await breakouts.clearSessions();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'url',
+          body: {
+            groups: [
+              {
+                action: BREAKOUTS.ACTION_TYPES.DELETE,
+              },
+            ],
+          }
+        });
+
+        assert.equal(breakouts.groups[0].status, "CLOSE")
+      });
+
+      it('rejects when edit lock token mismatch', async () => {
+        webex.request.returns(Promise.reject({
+          body: {
+            "errorCode":BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH,
+            "message":"Edit lock token mismatch"
+          }
+        }));
+
+        await assert.isRejected(
+          breakouts.clearSessions(),
+          BreakoutEditLockedError,
+          'Edit lock token mismatch'
+        );
+
+      });
+    });
+
+    describe('create', () => {
+      it('response not include groups info', async () => {
+        const sessions = [{'name':'session1', "anyoneCanJoin" : true}];
+        const result = await breakouts.create(sessions);
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+      });
+
+      it('response include groups info', async () => {
+        const sessions = [{'name':'session1', "anyoneCanJoin" : true}];
+
+        webex.request.returns(Promise.resolve({
+          body: {
+            groups: [{
+              id : "455556a4-37cd-4baa-89bc-8730581a1cc0",
+              status : "PENDING",
+              type : "BREAKOUT",
+            }]
+          }
+        }));
+
+        const result = await breakouts.create(sessions);
+
+        assert.equal(breakouts.groups[0].id, "455556a4-37cd-4baa-89bc-8730581a1cc0")
+
+      });
+
+      it('rejects when edit lock token mismatch', async () => {
+        const sessions = [{'name':'session1', "anyoneCanJoin" : true}];
+
+        webex.request.returns(Promise.reject({
+          body: {
+            "errorCode":BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH,
+            "message":"Edit lock token mismatch"
+          }
+        }));
+
+        await assert.isRejected(
+          breakouts.create(sessions),
+          BreakoutEditLockedError,
+          'Edit lock token mismatch'
+        );
+      });
+    });
   });
 });

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

@@ -10,9 +10,11 @@ describe('createMediaConnection', () => {
   };
   const fakeAudioTrack = {
     id: 'audio track',
+    underlyingTrack: 'underlying audio track',
   };
   const fakeVideoTrack = {
     id: 'video track',
+    underlyingTrack: 'underlying video track',
   };
 
   afterEach(() => {
@@ -80,9 +82,9 @@ describe('createMediaConnection', () => {
       },
       {
         send: {
-          audio: fakeAudioTrack,
-          video: fakeVideoTrack,
-          screenShareVideo: null,
+          audio: fakeAudioTrack.underlyingTrack,
+          video: fakeVideoTrack.underlyingTrack,
+          screenShareVideo: undefined,
         },
         receive: {
           audio: true,
@@ -190,9 +192,9 @@ describe('createMediaConnection', () => {
       },
       {
         send: {
-          audio: fakeAudioTrack,
-          video: null,
-          screenShareVideo: fakeVideoTrack,
+          audio: fakeAudioTrack.underlyingTrack,
+          video: undefined,
+          screenShareVideo: fakeVideoTrack.underlyingTrack,
         },
         receive: {
           audio: true,