@webex/plugin-meetings 3.0.0-beta.18 → 3.0.0-beta.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.18",
+  "version": "3.0.0-beta.19",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -32,12 +32,12 @@
     "build": "yarn run -T tsc --declaration true --declarationDir ./types"
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "3.0.0-beta.18",
-    "@webex/test-helper-chai": "3.0.0-beta.18",
-    "@webex/test-helper-mocha": "3.0.0-beta.18",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.18",
-    "@webex/test-helper-retry": "3.0.0-beta.18",
-    "@webex/test-helper-test-users": "3.0.0-beta.18",
+    "@webex/plugin-meetings": "3.0.0-beta.19",
+    "@webex/test-helper-chai": "3.0.0-beta.19",
+    "@webex/test-helper-mocha": "3.0.0-beta.19",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.19",
+    "@webex/test-helper-retry": "3.0.0-beta.19",
+    "@webex/test-helper-test-users": "3.0.0-beta.19",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
@@ -45,18 +45,18 @@
     "typed-emitter": "^2.1.0"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.18",
+    "@webex/common": "3.0.0-beta.19",
     "@webex/internal-media-core": "1.33.0",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.18",
-    "@webex/internal-plugin-device": "3.0.0-beta.18",
-    "@webex/internal-plugin-llm": "3.0.0-beta.18",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.18",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.18",
-    "@webex/internal-plugin-support": "3.0.0-beta.18",
-    "@webex/internal-plugin-user": "3.0.0-beta.18",
-    "@webex/plugin-people": "3.0.0-beta.18",
-    "@webex/plugin-rooms": "3.0.0-beta.18",
-    "@webex/webex-core": "3.0.0-beta.18",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.19",
+    "@webex/internal-plugin-device": "3.0.0-beta.19",
+    "@webex/internal-plugin-llm": "3.0.0-beta.19",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.19",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.19",
+    "@webex/internal-plugin-support": "3.0.0-beta.19",
+    "@webex/internal-plugin-user": "3.0.0-beta.19",
+    "@webex/plugin-people": "3.0.0-beta.19",
+    "@webex/plugin-rooms": "3.0.0-beta.19",
+    "@webex/webex-core": "3.0.0-beta.19",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",

package/src/meeting/index.ts

@@ -130,6 +130,7 @@ export const MEDIA_UPDATE_TYPE = {
   AUDIO: 'AUDIO',
   VIDEO: 'VIDEO',
   SHARE: 'SHARE',
+  LAMBDA: 'LAMBDA',
 };
 
 /**
@@ -5351,7 +5352,14 @@ export default class Meeting extends StatelessWebexPlugin {
    * @private
    * @memberof Meeting
    */
-  private enqueueMediaUpdate(mediaUpdateType: string, options: object) {
+  private enqueueMediaUpdate(mediaUpdateType: string, options: any) {
+    if (mediaUpdateType === MEDIA_UPDATE_TYPE.LAMBDA && typeof options?.lambda !== 'function') {
+      return Promise.reject(
+        new Error('lambda must be specified when enqueuing MEDIA_UPDATE_TYPE.LAMBDA')
+      );
+    }
+    const canUpdateMediaNow = this.canUpdateMedia();
+
     return new Promise((resolve, reject) => {
       const queueItem = {
         pendingPromiseResolve: resolve,
@@ -5364,6 +5372,10 @@ export default class Meeting extends StatelessWebexPlugin {
         `Meeting:index#enqueueMediaUpdate --> enqueuing media update type=${mediaUpdateType}`
       );
       this.queuedMediaUpdates.push(queueItem);
+
+      if (canUpdateMediaNow) {
+        this.processNextQueuedMediaUpdate();
+      }
     });
   }
 
@@ -5416,6 +5428,9 @@ export default class Meeting extends StatelessWebexPlugin {
         case MEDIA_UPDATE_TYPE.SHARE:
           this.updateShare(options).then(pendingPromiseResolve, pendingPromiseReject);
           break;
+        case MEDIA_UPDATE_TYPE.LAMBDA:
+          options.lambda().then(pendingPromiseResolve, pendingPromiseReject);
+          break;
         default:
           LoggerProxy.logger.error(
             `Peer-connection-manager:index#processNextQueuedMediaUpdate --> unsupported media update type ${mediaUpdateType} found in the queue`
@@ -5500,17 +5515,26 @@ export default class Meeting extends StatelessWebexPlugin {
           // now it's called independently from the roap message (so might be before it), check if that's OK
           // if not, ensure it's called after (now it's called after roap message is sent out, but we're not
           // waiting for sendRoapMediaRequest() to be resolved)
-          .then(() => this.checkForStopShare(mediaSettings.sendShare, previousSendShareStatus))
-          .then((startShare) => {
-            // This is a special case if we do an /floor grant followed by /media
-            // we actually get a OFFER from the server and a GLAR condition happens
-            if (startShare) {
-              // We are assuming that the clients are connected when doing an update
-              return this.requestScreenShareFloor();
-            }
-
-            return Promise.resolve();
-          })
+          .then(() =>
+            this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.LAMBDA, {
+              lambda: () => {
+                return Promise.resolve()
+                  .then(() =>
+                    this.checkForStopShare(mediaSettings.sendShare, previousSendShareStatus)
+                  )
+                  .then((startShare) => {
+                    // This is a special case if we do an /floor grant followed by /media
+                    // we actually get a OFFER from the server and a GLAR condition happens
+                    if (startShare) {
+                      // We are assuming that the clients are connected when doing an update
+                      return this.requestScreenShareFloor();
+                    }
+
+                    return Promise.resolve();
+                  });
+              },
+            })
+          )
       );
   }
 
@@ -5706,13 +5730,17 @@ export default class Meeting extends StatelessWebexPlugin {
               remoteQualityLevel: this.mediaProperties.remoteQualityLevel,
             },
           })
-          .then(() => {
-            if (startShare) {
-              return this.requestScreenShareFloor();
-            }
+          .then(() =>
+            this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.LAMBDA, {
+              lambda: async () => {
+                if (startShare) {
+                  return this.requestScreenShareFloor();
+                }
 
-            return Promise.resolve();
-          })
+                return undefined;
+              },
+            })
+          )
       )
       .then(() => {
         this.mediaProperties.mediaDirection.sendShare = sendShare;

package/test/unit/spec/meeting/index.js

@@ -2209,6 +2209,190 @@ describe('plugin-meetings', () => {
           );
           assert.isTrue(myPromiseResolved);
         });
+
+        it('should request floor only after roap transaction is completed', async () => {
+          const eventListeners = {};
+
+          meeting.webex.meetings.reachability = {
+            isAnyClusterReachable: sandbox.stub().resolves(true)
+          };
+
+          const fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            }),
+
+            updateSendReceiveOptions: sinon.stub().callsFake(() => {
+              // trigger ROAP_STARTED before updateSendReceiveOptions() resolves
+              if (eventListeners[Event.ROAP_STARTED]) {
+                eventListeners[Event.ROAP_STARTED]();
+              } else {
+                throw new Error('ROAP_STARTED listener not registered')
+              }
+              return Promise.resolve();
+            }),
+          };
+
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
+
+          const requestScreenShareFloorStub = sandbox.stub(meeting, 'requestScreenShareFloor').resolves({});
+
+          let myPromiseResolved = false;
+
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {},
+          });
+
+          meeting
+            .updateMedia({
+              localShare: mockLocalShare,
+              mediaSettings: {
+                sendShare: true,
+              },
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.isFalse(myPromiseResolved);
+
+          // verify that requestScreenShareFloorStub was not called yet
+          assert.notCalled(requestScreenShareFloorStub);
+
+          eventListeners[Event.ROAP_DONE]();
+          await testUtils.flushPromises();
+
+          // now it should have been called
+          assert.calledOnce(requestScreenShareFloorStub);
+        });
+      });
+
+      describe('#updateShare', () => {
+        const mockLocalShare = {id: 'mock local share stream'};
+        let eventListeners;
+        let fakeMediaConnection;
+        let requestScreenShareFloorStub;
+
+        const FAKE_TRACKS = {
+          screenshareVideo: {
+            id: 'fake share track',
+            getSettings: sinon.stub().returns({}),
+          },
+        };
+
+        beforeEach(async () => {
+          eventListeners = {};
+
+          sinon.stub(MeetingUtil, 'getTrack').callsFake((stream) => {
+            if (stream === mockLocalShare) {
+              return {audioTrack: null, videoTrack: FAKE_TRACKS.screenshareVideo};
+            }
+
+            return {audioTrack: null, videoTrack: null};
+          });
+
+          meeting.webex.meetings.reachability = {
+            isAnyClusterReachable: sinon.stub().resolves(true)
+          };
+
+          fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            }),
+
+            updateSendReceiveOptions: sinon.stub().callsFake(() => {
+              // trigger ROAP_STARTED before updateSendReceiveOptions() resolves
+              if (eventListeners[Event.ROAP_STARTED]) {
+                eventListeners[Event.ROAP_STARTED]();
+              } else {
+                throw new Error('ROAP_STARTED listener not registered')
+              }
+              return Promise.resolve();
+            }),
+          };
+
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
+
+          requestScreenShareFloorStub = sinon.stub(meeting, 'requestScreenShareFloor').resolves({});
+
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {},
+          });
+        });
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('when starting share, it should request floor only after roap transaction is completed', async () => {
+          let myPromiseResolved = false;
+
+          meeting
+            .updateShare({
+              sendShare: true,
+              receiveShare: true,
+              stream: mockLocalShare,
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.isFalse(myPromiseResolved);
+
+          // verify that requestScreenShareFloorStub was not called yet
+          assert.notCalled(requestScreenShareFloorStub);
+
+          eventListeners[Event.ROAP_DONE]();
+          await testUtils.flushPromises();
+
+          // now it should have been called
+          assert.calledOnce(requestScreenShareFloorStub);
+        });
+
+        it('when changing screen share stream and no roap transaction happening, it requests floor immediately', async () => {
+          let myPromiseResolved = false;
+
+          // simulate a case when no roap transaction is triggered by updateSendReceiveOptions
+          meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions = sinon.stub().resolves({});
+
+          meeting
+            .updateShare({
+              sendShare: true,
+              receiveShare: true,
+              stream: mockLocalShare,
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.calledOnce(requestScreenShareFloorStub);
+          assert.isTrue(myPromiseResolved);
+        });
       });
 
       describe('#changeVideoLayout', () => {