@webex/plugin-meetings 1.149.2 → 1.150.0

package/src/meeting/request.js

@@ -523,13 +523,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       };
     }
 
+    const body = {
+      floor: floorReq,
+      resourceUrl: options.resourceUrl
+    };
+
+    if (options?.resourceToken) {
+      body.resourceToken = options?.resourceToken;
+    }
+
     return this.request({
       uri: options.uri,
       method: HTTP_VERBS.PUT,
-      body: {
-        floor: floorReq,
-        resourceUrl: options.resourceUrl
-      }
+      body
     });
   }
 

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)]))
@@ -550,6 +552,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}]),