@webex/plugin-meetings 1.149.2 → 1.151.1

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/src/metrics/index.js

@@ -6,10 +6,10 @@ import util from 'util';
 import {includes} from 'lodash';
 import uuid from 'uuid';
 import window from 'global/window';
+import anonymize from 'ip-anonymize';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {MEETING_ERRORS} from '../constants';
-import StaticConfig from '../common/config';
 import BrowserDetection from '../common/browser-detection';
 
 import {
@@ -34,21 +34,19 @@ const {
 } = BrowserDetection();
 
 // Apply a CIDR /28 format to the IP address
-const getLocalNetworkPrefix = (localIp) => {
-  if (!localIp) {
-    return undefined;
-  }
-  const parts = localIp.split('.');
-
-  // eslint-disable-next-line no-bitwise
-  parts[3] &= 240;
-
-  return parts.join('.');
-};
+const anonymizeIPAddress = (localIp) => anonymize(localIp);
 
 const triggerTimers = ({event, meeting, data}) => {
   switch (event) {
+    case eventType.CALL_INITIATED:
+      meeting.setStartCallInitiateJoinReq();
+      break;
+    case eventType.LOCUS_JOIN_REQUEST:
+      meeting.setEndCallInitiateJoinReq();
+      meeting.setStartJoinReqResp();
+      break;
     case eventType.LOCUS_JOIN_RESPONSE:
+      meeting.setEndJoinReqResp();
       meeting.setStartSetupDelay(mediaType.AUDIO);
       meeting.setStartSetupDelay(mediaType.VIDEO);
       meeting.setStartSendingMediaDelay(mediaType.AUDIO);
@@ -60,6 +58,12 @@ const triggerTimers = ({event, meeting, data}) => {
     case eventType.SENDING_MEDIA_START:
       meeting.setEndSendingMediaDelay(data.mediaType);
       break;
+    case eventType.LOCAL_SDP_GENERATED:
+      meeting.setStartLocalSDPGenRemoteSDPRecvDelay();
+      break;
+    case eventType.REMOTE_SDP_RECEIVED:
+      meeting.setEndLocalSDPGenRemoteSDPRecvDelay();
+      break;
     default:
       break;
   }
@@ -144,6 +148,7 @@ class Metrics {
 
     if (!meeting && meetingId) {
       meeting = this.meetingCollection.get(meetingId);
+      options.meeting = meeting;
     }
 
     if (meeting) {
@@ -185,7 +190,7 @@ class Metrics {
         clientInfo: {
           clientType: options.clientType,
           clientVersion: `${CLIENT_NAME}/${this.webex.version}`,
-          localNetworkPrefix: getLocalNetworkPrefix(this.webex.meetings.geoHintInfo?.clientAddress),
+          localNetworkPrefix: anonymizeIPAddress(this.webex.meetings.geoHintInfo?.clientAddress),
           osVersion: getOSVersion() || 'unknown',
           subClientType: options.subClientType,
           os: this.getOsName(),
@@ -228,6 +233,9 @@ class Metrics {
       if (options.recoveredBy) {
         payload.event.recoveredBy = options.recoveredBy;
       }
+      if (options.joinTimes) {
+        payload.event.joinTimes = options.joinTimes;
+      }
     }
 
     return payload;
@@ -259,7 +267,7 @@ class Metrics {
    * @memberof Metrics
    */
   initMediaPayload(eventType, identifiers, options = {}) {
-    const {audioSetupDelay, videoSetupDelay} = options;
+    const {audioSetupDelay, videoSetupDelay, joinTimes} = options;
 
     const payload = {
       eventId: uuid.v4(),
@@ -273,7 +281,7 @@ class Metrics {
         clientInfo: {
           clientType: options.clientType, // TODO: Only clientType: 'TEAMS_CLIENT' is whitelisted
           clientVersion: `${CLIENT_NAME}/${this.webex.version}`,
-          localNetworkPrefix: getLocalNetworkPrefix(this.webex.meetings.geoHintInfo?.clientAddress),
+          localNetworkPrefix: anonymizeIPAddress(this.webex.meetings.geoHintInfo?.clientAddress),
           os: this.getOsName(),
           osVersion: getOSVersion() || UNKNOWN,
           subClientType: options.subClientType,
@@ -290,7 +298,10 @@ class Metrics {
         canProceed: true,
         identifiers,
         intervals: [options.intervalData],
-        eventData: {webClientDomain: window.location.hostname},
+        joinTimes,
+        eventData: {
+          webClientDomain: window.location.hostname
+        },
         sourceMetadata: {
           applicationSoftwareType: CLIENT_NAME,
           applicationSoftwareVersion: this.webex.version,
@@ -455,7 +466,7 @@ class Metrics {
   userAgentToString() {
     let userAgentOption;
     let browserInfo;
-    const clientInfo = util.format('client=%s', `${StaticConfig.meetings.metrics.clientName}`);
+    const clientInfo = util.format('client=%s', `${this.webex.meetings?.metrics?.clientName}`);
 
     if (['chrome', 'firefox', 'msie', 'msedge', 'safari'].indexOf(getBrowserName().toLowerCase()) !== -1) {
       browserInfo = util.format('browser=%s', `${getBrowserName().toLowerCase()}/${getBrowserVersion().split('.')[0]}`);

package/src/peer-connection-manager/index.js

@@ -288,7 +288,12 @@ pc.addStream = (peerConnection, stream) => {
  * @param {String} meetingId
  * @returns {undefined}
  */
-pc.setRemoteSessionDetails = (peerConnection, typeStr, remoteSdp, meetingId) => {
+pc.setRemoteSessionDetails = (
+  peerConnection,
+  typeStr,
+  remoteSdp,
+  meetingId,
+) => {
   LoggerProxy.logger.log(`PeerConnectionManager:index#setRemoteSessionDetails --> Setting the remote description type: ${typeStr}State: ${peerConnection.signalingState}`);
   const sdp = remoteSdp;
 
@@ -314,7 +319,7 @@ pc.setRemoteSessionDetails = (peerConnection, typeStr, remoteSdp, meetingId) =>
       })
     )
       .then(() => {
-        if (!peerConnection.remoteDescription) {
+        if (peerConnection.signalingState === SDP.STABLE) {
           Metrics.postEvent({
             event: eventType.REMOTE_SDP_RECEIVED,
             meetingId

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,7 +519,10 @@ skipInNode(describe)('plugin-meetings', () => {
           .then((response) => {
             assert.equal(response[0].result.memberId, alice.meeting.selfId);
           }),
-        testUtils.waitForEvents([{scope: bob.meeting.members, event: 'members:update'}]),
+        testUtils.waitForEvents([{scope: bob.meeting.members, event: 'members:update'}])
+          .then((response) => {
+            console.log('SCREEN SHARE RESPONSE ', JSON.stringify(response, testUtils.getCircularReplacer()));
+          }),
         testUtils.waitForEvents([{scope: alice.meeting, event: 'media:ready'}])
           .then((response) => {
             console.log('MEDIA:READY event ', response[0].result);
@@ -512,7 +552,7 @@ skipInNode(describe)('plugin-meetings', () => {
           }),
         testUtils.waitForEvents([{scope: alice.meeting.members, event: 'members:update'}])
           .then((response) => {
-            console.log('SCREEN SHARE RESPONSE ', JSON.stringify(response));
+            console.log('SCREEN SHARE RESPONSE ', JSON.stringify(response, testUtils.getCircularReplacer()));
           }),
         testUtils.waitForEvents([{scope: bob.meeting, event: 'media:ready'}])
           .then((response) => {
@@ -550,6 +590,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, testUtils.getCircularReplacer()));
+          })
+      ])
+        .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, testUtils.getCircularReplacer()));
+          })
+      ])
+        .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, testUtils.getCircularReplacer()));
+          })
+      ])
+        .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.getCircularReplacer()));
+          }),
+        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, testUtils.getCircularReplacer()));
+          })
+      ])
+        .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';
@@ -63,18 +65,39 @@ skipInNode(describe)('plugin-meetings', () => {
           testUtils.delayedPromise(alice.meeting.join()),
           testUtils.waitForEvents([
             {scope: bob.webex.meetings, event: 'meeting:added', user: bob},
-            {scope: chris.webex.meetings, event: 'meeting:added', user: chris}])
-        ])));
+            {scope: chris.webex.meetings, event: 'meeting:added', user: chris}
+          ])
+        ]).then(() => {
+          const {meetingNumber} = bob.meeting.meetingInfo;
+
+          assert(meetingNumber === alice.meeting.meetingNumber, 'meetingNumber matches alice meeting number');
+        })));
+
+    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')