@webex/plugin-meetings 1.149.0 → 1.150.1

package/src/members/index.js

@@ -4,7 +4,7 @@
 import {isEmpty} from 'lodash';
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
-import {MEETINGS, EVENT_TRIGGERS, FLOOR_ACTION, CONTENT} from '../constants';
+import {MEETINGS, EVENT_TRIGGERS, FLOOR_ACTION, CONTENT, WHITEBOARD} from '../constants';
 import Trigger from '../common/events/trigger-proxy';
 import Member from '../member';
 import LoggerProxy from '../common/logs/logger-proxy';
@@ -132,6 +132,14 @@ export default class Members extends StatelessWebexPlugin {
      * @memberof Members
     */
     this.mediaShareContentId = null;
+    /**
+     * The current mediaShareWhiteboardId for the meeting
+     * @instance
+     * @type {String}
+     * @private
+     * @memberof Members
+    */
+    this.mediaShareWhiteboardId = null;
     /**
      * The current recordingId for the meeting, if it exists
      * @instance
@@ -281,20 +289,49 @@ export default class Members extends StatelessWebexPlugin {
    * @memberof Members
    */
   locusMediaSharesUpdate(payload) {
-    const currentContent = payload.current;
-    const previousContent = payload.previous;
+    const currentContent = payload.current?.content;
+    const previousContent = payload.previous?.content;
+    const currentWhiteboard = payload.current?.whiteboard;
+    const previousWhiteboard = payload.previous?.whiteboard;
     let whoSharing = null;
     let whoStopped = null;
 
-    if (currentContent && currentContent.contentId) {
+    if (currentContent?.beneficiaryId) {
       if (currentContent.disposition === FLOOR_ACTION.GRANTED) {
-        whoSharing = currentContent.contentId;
-        whoStopped = previousContent && previousContent.contentId;
+        whoSharing = currentContent.beneficiaryId;
+        this.mediaShareWhiteboardId = null;
+        this.mediaShareContentId = whoSharing;
+      }
+
+      if (previousContent?.disposition === FLOOR_ACTION.GRANTED) {
+        if (currentContent.disposition === FLOOR_ACTION.RELEASED) {
+          whoStopped = currentContent.beneficiaryId;
+          this.mediaShareContentId = null;
+        }
+        else if (currentContent.disposition === FLOOR_ACTION.GRANTED && currentContent.beneficiaryId !== previousContent.beneficiaryId) {
+          whoStopped = previousContent.beneficiaryId;
+        }
       }
-      else if (currentContent.disposition === FLOOR_ACTION.RELEASED) {
-        whoStopped = currentContent.contentId;
+    }
+
+    if (currentWhiteboard?.beneficiaryId) {
+      if (currentWhiteboard.disposition === FLOOR_ACTION.GRANTED) {
+        whoSharing = currentWhiteboard.beneficiaryId;
+        this.mediaShareContentId = null;
+        this.mediaShareWhiteboardId = whoSharing;
+      }
+
+      if (previousWhiteboard?.disposition === FLOOR_ACTION.GRANTED) {
+        if (currentWhiteboard.disposition === FLOOR_ACTION.RELEASED) {
+          whoStopped = currentWhiteboard.beneficiaryId;
+          this.mediaShareWhiteboardId = null;
+        }
+        else if (currentWhiteboard.disposition === FLOOR_ACTION.GRANTED && currentWhiteboard.beneficiaryId !== previousWhiteboard.beneficiaryId) {
+          whoStopped = previousWhiteboard.beneficiaryId;
+        }
       }
     }
+
     if (whoSharing) {
       const shareMember = this.membersCollection.get(whoSharing);
 
@@ -309,7 +346,7 @@ export default class Members extends StatelessWebexPlugin {
         stopMember.setIsContentSharing(false);
       }
     }
-    this.mediaShareContentId = whoSharing;
+
     Trigger.trigger(
       this,
       {
@@ -318,8 +355,8 @@ export default class Members extends StatelessWebexPlugin {
       },
       EVENT_TRIGGERS.MEMBERS_CONTENT_UPDATE,
       {
-        activeContentSharingId: whoSharing,
-        endedContentSharingId: whoStopped
+        activeSharingId: whoSharing,
+        endedSharingId: whoStopped
       }
     );
   }
@@ -524,6 +561,36 @@ export default class Members extends StatelessWebexPlugin {
     }
   }
 
+  /**
+   * Update the media share whiteboard id
+   * @param {Object} locus
+   * @param {String} [whiteboardId] optional, takes precedence
+   * @throws {Error}
+   * @returns {undefined}
+   * @memberof Members
+   */
+  setMediaShareWhiteboardId(locus, whiteboardId) {
+    if (whiteboardId) {
+      this.mediaShareWhiteboardId = whiteboardId;
+    }
+    else if (locus) {
+      const whiteboardMediaShare =
+        locus.mediaShares &&
+        locus.mediaShares.length &&
+        locus.mediaShares.find((mediaShare) => mediaShare.name === WHITEBOARD);
+
+      this.mediaShareWhiteboardId =
+        (whiteboardMediaShare &&
+          whiteboardMediaShare.floor &&
+          whiteboardMediaShare.floor.beneficiary &&
+          whiteboardMediaShare.floor.beneficiary.id) ||
+        null;
+    }
+    else {
+      throw new ParameterError('Setting hostid for the Members module should be done with a locus object or hostId');
+    }
+  }
+
   /**
    * Find all the updates, and added members
    * Removed/left members will end up in updates
@@ -552,6 +619,7 @@ export default class Members extends StatelessWebexPlugin {
               selfId: this.selfId,
               hostId: this.hostId,
               contentSharingId: this.mediaShareContentId,
+              whiteboardSharingId: this.mediaShareWhiteboardId,
               type: this.type
             })
           );
@@ -563,6 +631,7 @@ export default class Members extends StatelessWebexPlugin {
               selfId: this.selfId,
               hostId: this.hostId,
               contentSharingId: this.mediaShareContentId,
+              whiteboardSharingId: this.mediaShareWhiteboardId,
               type: this.type
             })
           );

package/src/metrics/config.js

@@ -126,6 +126,12 @@ export const eventType = {
   // Fired when the client changes its local UI/layout to a content sharing view,
   // because it is expecting to display share media.
   SHARE_LAYOUT_DISPLAYED: 'client.share.layout.displayed',
+  // Fired when the user of the client starts a whiteboard share (e.g. click 'Share Live' button).
+  WHITEBOARD_SHARE_INITIATED: 'client.whiteboard.share.initiated',
+  // Fired when the meeting floor is released for whiteboard share
+  WHITEBOARD_SHARE_STOPPED: 'client.whiteboard.share.stopped',
+  // When the client receives a successful response from locus indicating that it has the floor for whiteboard sharing.
+  WHITEBOARD_SHARE_FLOOR_GRANTED: 'client.whiteboard.share.floor-granted',
   MUTED: 'client.muted',
   UNMUTED: 'client.unmuted',
   LEAVE: 'client.call.leave',

package/test/integration/spec/journey.js

@@ -13,7 +13,7 @@ const webexTestUsers = require('../../utils/webex-test-users');
 
 const {isBrowser} = BrowserDetection();
 
-let userSet, alice, bob, chris, enumerateSpy;
+let userSet, alice, bob, chris, enumerateSpy, channelUrlA, channelUrlB;
 
 skipInNode(describe)('plugin-meetings', () => {
   describe('journey', () => {
@@ -32,6 +32,8 @@ skipInNode(describe)('plugin-meetings', () => {
         alice.webex.meetings.name = 'alice';
         bob.webex.meetings.name = 'bob';
         chris.webex.meetings.name = 'chris';
+        channelUrlA = 'https://board-a.wbx2.com/board/api/v1/channels/49cfb550-5517-11eb-a2af-1b9e4bc3da13';
+        channelUrlB = 'https://board-a.wbx2.com/board/api/v1/channels/977a7330-54f4-11eb-b1ef-91f5eefc7bf3';
       })
       .then(() => Promise.all([testUtils.syncAndEndMeeting(alice),
         testUtils.syncAndEndMeeting(bob)]))
@@ -162,6 +164,41 @@ skipInNode(describe)('plugin-meetings', () => {
         }));
     });
 
+    // Enabled when config.enableUnifiedMeetings = true
+    xdescribe('Conversation URL', () => {
+      describe('Successful 1:1 meeting', () => {
+        it('Fetch meeting information with a conversation URL for a 1:1 space', async () => {
+          assert.equal(Object.keys(bob.webex.meetings.getAllMeetings()), 0);
+          assert.equal(Object.keys(chris.webex.meetings.getAllMeetings()), 0);
+
+          const conversation = await chris.webex.internal.conversation.create({participants: [bob]});
+
+          await chris.webex.internal.conversation.post(conversation, {displayName: 'hello world how are you '});
+
+          await Promise.all([
+            testUtils.delayedPromise(chris.webex.meetings.create(conversation.url, 'CONVERSATION_URL')),
+            testUtils.waitForEvents([{scope: chris.webex.meetings, event: 'meeting:added', user: chris}])
+          ])
+            .then(function chrisJoinsMeeting() {
+              return Promise.all([
+                testUtils.delayedPromise(chris.meeting.join()),
+                testUtils.waitForEvents([{scope: bob.webex.meetings, event: 'meeting:added', user: bob},
+                  {scope: chris.meeting, event: 'meeting:stateChange', user: chris}])
+                  .then((response) => {
+                    assert.equal(response[0].result.payload.currentState, 'ACTIVE');
+                  })
+              ]);
+            });
+        });
+
+        it('Fetch meeting information with invalid conversation URL and throws error', () => {
+          chris.webex.meetings.meetingInfo.fetchMeetingInfo('http://some-invalid.com', 'CONVERSATION_URL').then((response) => {
+            assert(response.result === '404');
+          });
+        });
+      });
+    });
+
     describe('Successful 1:1 meeting (including Guest)', function () {
       before(() => {
         // Workaround since getDisplayMedia requires a user gesture to be activated, and this is a integration tests
@@ -482,10 +519,7 @@ skipInNode(describe)('plugin-meetings', () => {
           .then((response) => {
             assert.equal(response[0].result.memberId, alice.meeting.selfId);
           }),
-        testUtils.waitForEvents([{scope: bob.meeting.members, event: 'members:update'}])
-          .then((response) => {
-            console.log('SCREEN SHARE RESPONSE ', JSON.stringify(response));
-          }),
+        testUtils.waitForEvents([{scope: bob.meeting.members, event: 'members:update'}]),
         testUtils.waitForEvents([{scope: alice.meeting, event: 'media:ready'}])
           .then((response) => {
             console.log('MEDIA:READY event ', response[0].result);
@@ -553,6 +587,143 @@ skipInNode(describe)('plugin-meetings', () => {
           assert.equal(alice.meeting.shareStatus, 'no_share');
         }));
 
+      it('alice shares whiteboard A', () => Promise.all([
+        testUtils.delayedPromise(alice.meeting.startWhiteboardShare(channelUrlA)),
+        testUtils.waitForEvents([
+          {scope: alice.meeting, event: 'meeting:startedSharingWhiteboard'}
+        ]),
+        testUtils.waitForEvents([{scope: bob.meeting, event: 'meeting:startedSharingWhiteboard'}])
+          .then((response) => {
+            const {memberId, resourceUrl} = response[0].result;
+
+            assert.equal(memberId, alice.meeting.selfId);
+            assert.equal(resourceUrl, channelUrlA);
+          }),
+        testUtils.waitForEvents([{scope: bob.meeting.members, event: 'members:update'}])
+          .then((response) => {
+            console.log('WHITEBOARD SHARE RESPONSE ', JSON.stringify(response));
+          })
+      ])
+        .then(() => {
+          assert.equal(alice.meeting.isSharing, false);
+          assert.equal(alice.meeting.shareStatus, 'whiteboard_share_active');
+          assert.equal(bob.meeting.shareStatus, 'whiteboard_share_active');
+        }));
+
+      it('bob steals share from alice with whiteboard B', () => Promise.all([
+        testUtils.delayedPromise(bob.meeting.startWhiteboardShare(channelUrlB)),
+        testUtils.waitForEvents([
+          {scope: bob.meeting, event: 'meeting:startedSharingWhiteboard'}
+        ]),
+        testUtils.waitForEvents([{scope: alice.meeting, event: 'meeting:startedSharingWhiteboard'}])
+          .then((response) => {
+            const {memberId, resourceUrl} = response[0].result;
+
+            assert.equal(memberId, bob.meeting.selfId);
+            assert.equal(resourceUrl, channelUrlB);
+          }),
+        testUtils.waitForEvents([{scope: alice.meeting.members, event: 'members:update'}])
+          .then((response) => {
+            console.log('WHITEBOARD SHARE RESPONSE ', JSON.stringify(response));
+          })
+      ])
+        .then(() => {
+          assert.equal(bob.meeting.isSharing, false);
+          assert.equal(alice.meeting.shareStatus, 'whiteboard_share_active');
+          assert.equal(bob.meeting.shareStatus, 'whiteboard_share_active');
+        }));
+
+      it('bob stops sharing ', () => Promise.all([
+        // Wait for peerConnection to stabalize
+        testUtils.waitUntil(20000),
+        testUtils.delayedPromise(bob.meeting.stopWhiteboardShare(channelUrlB)),
+        testUtils.waitForEvents([{scope: bob.meeting, event: 'meeting:stoppedSharingWhiteboard'}]),
+        testUtils.waitForEvents([{scope: alice.meeting, event: 'meeting:stoppedSharingWhiteboard'}])
+      ])
+        .then(() => {
+          assert.equal(bob.meeting.isSharing, false);
+          assert.equal(bob.meeting.shareStatus, 'no_share');
+          assert.equal(alice.meeting.shareStatus, 'no_share');
+        }));
+
+      it('alice shares whiteboard B', () => Promise.all([
+        testUtils.delayedPromise(alice.meeting.startWhiteboardShare(channelUrlB)),
+        testUtils.waitForEvents([
+          {scope: alice.meeting, event: 'meeting:startedSharingWhiteboard'}
+        ]),
+        testUtils.waitForEvents([{scope: bob.meeting, event: 'meeting:startedSharingWhiteboard'}])
+          .then((response) => {
+            const {memberId, resourceUrl} = response[0].result;
+
+            assert.equal(memberId, alice.meeting.selfId);
+            assert.equal(resourceUrl, channelUrlB);
+          }),
+        testUtils.waitForEvents([{scope: bob.meeting.members, event: 'members:update'}])
+          .then((response) => {
+            console.log('WHITEBOARD SHARE RESPONSE ', JSON.stringify(response));
+          })
+      ])
+        .then(() => {
+          assert.equal(alice.meeting.isSharing, false);
+          assert.equal(alice.meeting.shareStatus, 'whiteboard_share_active');
+          assert.equal(bob.meeting.shareStatus, 'whiteboard_share_active');
+        }));
+
+      it('bob steals the share from alice with desktop share', () => Promise.all([
+        testUtils.delayedPromise(bob.meeting.shareScreen()),
+        testUtils.waitForEvents([{scope: alice.meeting, event: 'meeting:stoppedSharingWhiteboard'}]),
+        testUtils.waitForEvents([{scope: bob.meeting, event: 'meeting:startedSharingLocal'}]),
+        testUtils.waitForEvents([{scope: alice.meeting, event: 'meeting:startedSharingRemote'}])
+          .then((response) => {
+            assert.equal(response[0].result.memberId, bob.meeting.selfId);
+          }),
+        testUtils.waitForEvents([{scope: alice.meeting.members, event: 'members:update'}])
+          .then((response) => {
+            console.log('SCREEN SHARE RESPONSE ', JSON.stringify(response));
+          }),
+        testUtils.waitForEvents([{scope: bob.meeting, event: 'media:ready'}])
+          .then((response) => {
+            console.log('MEDIA:READY event ', response[0].result);
+            assert.equal(response[0].result.type === 'localShare', true);
+          })
+      ])
+        .then(() => {
+          const heightResolution = DEFAULT_RESOLUTIONS.meetings.screenResolution.idealHeight;
+
+          // TODO: Re-eanable Safari when screensharing issues have been resolved
+          if (!isBrowser('safari')) {
+            assert.equal(bob.meeting.mediaProperties.shareTrack.getConstraints().height, heightResolution);
+          }
+          assert.equal(bob.meeting.isSharing, true);
+          assert.equal(bob.meeting.shareStatus, 'local_share_active');
+          assert.equal(alice.meeting.shareStatus, 'remote_share_active');
+
+          return testUtils.waitUntil(10000);
+        }));
+
+      it('bob shares whiteboard B', () => Promise.all([
+        testUtils.delayedPromise(bob.meeting.startWhiteboardShare(channelUrlB)),
+        testUtils.waitForEvents([
+          {scope: bob.meeting, event: 'meeting:startedSharingWhiteboard'}
+        ]),
+        testUtils.waitForEvents([{scope: alice.meeting, event: 'meeting:startedSharingWhiteboard'}])
+          .then((response) => {
+            const {memberId, resourceUrl} = response[0].result;
+
+            assert.equal(memberId, bob.meeting.selfId);
+            assert.equal(resourceUrl, channelUrlB);
+          }),
+        testUtils.waitForEvents([{scope: alice.meeting.members, event: 'members:update'}])
+          .then((response) => {
+            console.log('WHITEBOARD SHARE RESPONSE ', JSON.stringify(response));
+          })
+      ])
+        .then(() => {
+          assert.equal(bob.meeting.isSharing, false);
+          assert.equal(alice.meeting.shareStatus, 'whiteboard_share_active');
+          assert.equal(bob.meeting.shareStatus, 'whiteboard_share_active');
+        }));
+
       it('alice adds chris as guest to 1:1 meeting', () => Promise.all([
         testUtils.delayedPromise(alice.meeting.invite({emailAddress: chris.emailAddress})),
         testUtils.waitForEvents([{scope: chris.webex.meetings, event: 'meeting:added', user: chris}]),

package/test/integration/spec/space-meeting.js

@@ -1,6 +1,8 @@
 
 import {assert} from '@webex/test-helper-chai';
 import {skipInNode, jenkinsOnly} from '@webex/test-helper-mocha';
+import {patterns} from '@webex/common';
+import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 
 import CMR from '../../utils/cmr';
 import testUtils from '../../utils/testUtils';
@@ -44,6 +46,15 @@ skipInNode(describe)('plugin-meetings', () => {
           console.log('CONVERSATION', conversation);
           space = conversation;
         })
+        .then(async () => {
+          const destinationWithType = await alice.webex.meetings.meetingInfo.fetchMeetingInfo(space.url, 'CONVERSATION_URL');
+          const destinationNoType = await alice.webex.meetings.meetingInfo.fetchMeetingInfo(space.url);
+
+          assert.exists(destinationNoType);
+          assert.exists(destinationWithType);
+          assert.exists(destinationNoType.body.meetingNumber);
+          assert.exists(destinationWithType.body.meetingNumber);
+        })
         .then(function aliceStartsMeeting() {
           return Promise.all([
             testUtils.delayedPromise(alice.webex.meetings.create(space.url)),
@@ -57,17 +68,34 @@ skipInNode(describe)('plugin-meetings', () => {
             {scope: chris.webex.meetings, event: 'meeting:added', user: chris}])
         ])));
 
+    xit('Should fetch user info using user hydra id with the new api', () => alice.webex.rooms.create({title: 'sample'})
+      .then((room) => MeetingInfoUtil.getDestinationType({
+        destination: room.creatorId,
+        webex: alice.webex
+      }))
+      .then((destinationType) => MeetingInfoUtil.getRequestBody(destinationType))
+      .then((res) => {
+        assert.exists(res.sipUrl, 'sipURL didnt exist');
+        assert.match(res.sipUrl, patterns.email); // assert sipURL is email
+      }));
+
     // Enable this test when we are going to enable the unified space meeeting .
     // We cannot change the config on load as the meetingInfo function loads dynamically
-    xit('Should fetch meeting Info using the new api', async () => {
-      alice.webex.meetings.config.experimental.enableUnifiedMeetings = true;
+    xit('Should fetch meeting info using space url with the new api', async () => {
       const res = await alice.webex.meetings.meetingInfo.fetchMeetingInfo(space.url, 'CONVERSATION_URL');
 
-      assert.exists(res.meetingNumber);
+      assert.exists(res.body.meetingNumber);
+    });
+
+    xit('Bob fetches meeting info with SIP URI before joining', async () => {
+      const {sipUri} = alice.meeting;
+      const res = await bob.webex.meetings.meetingInfo.fetchMeetingInfo(sipUri, 'SIP_URI');
+      const {meetingNumber} = res.body;
 
-      alice.webex.meetings.config.experimental.enableUnifiedMeetings = false;
+      assert(meetingNumber === alice.meeting.meetingNumber, 'meetingNumber matches alice meeting number');
     });
 
+
     it('Bob and chris joins space meeting', () => testUtils.waitForStateChange(alice.meeting, 'JOINED')
       .then(() => testUtils.waitForStateChange(bob.meeting, 'IDLE'))
       .then(() => testUtils.waitForStateChange(chris.meeting, 'IDLE'))
@@ -97,7 +125,7 @@ skipInNode(describe)('plugin-meetings', () => {
 
 
     it('alice adds x user as guest to space meeting', () => Promise.all([
-      testUtils.delayedPromise(guest.webex.meetings.create(alice.meeting.meetingInfo.uri)),
+      testUtils.delayedPromise(guest.webex.meetings.create(alice.meeting.sipUri)),
       testUtils.waitForEvents([{scope: guest.webex.meetings, event: 'meeting:added', user: guest}])
     ]).then(() =>
       Promise.all([