@webex/plugin-meetings 3.7.0-next.41 → 3.7.0-next.43

package/dist/types/meetings/meetings.types.d.ts

@@ -11,3 +11,11 @@ export declare const MEETING_KEY: {
     readonly CORRELATION_ID: "correlationId";
 };
 export type MEETING_KEY = Enum<typeof MEETING_KEY>;
+export type MeetingRegistrationStatus = {
+    fetchWebexSite: boolean;
+    getGeoHint: boolean;
+    startReachability: boolean;
+    deviceRegister: boolean;
+    mercuryConnect: boolean;
+    checkH264Support: boolean;
+};

package/dist/webinar/index.js

@@ -458,7 +458,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee7);
     }))();
   },
-  version: "3.7.0-next.41"
+  version: "3.7.0-next.43"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,7 +43,7 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "3.7.0-next.41",
+    "@webex/plugin-meetings": "3.7.0-next.43",
     "@webex/plugin-rooms": "3.7.0-next.17",
     "@webex/test-helper-chai": "3.7.0-next.12",
     "@webex/test-helper-mocha": "3.7.0-next.12",
@@ -71,7 +71,7 @@
     "@webex/internal-plugin-metrics": "3.7.0-next.12",
     "@webex/internal-plugin-support": "3.7.0-next.18",
     "@webex/internal-plugin-user": "3.7.0-next.12",
-    "@webex/internal-plugin-voicea": "3.7.0-next.41",
+    "@webex/internal-plugin-voicea": "3.7.0-next.43",
     "@webex/media-helpers": "3.7.0-next.16",
     "@webex/plugin-people": "3.7.0-next.15",
     "@webex/plugin-rooms": "3.7.0-next.17",
@@ -92,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.7.0-next.41"
+  "version": "3.7.0-next.43"
 }

package/src/constants.ts

@@ -1389,3 +1389,12 @@ export const DESTINATION_TYPE = {
 } as const;
 
 export type DESTINATION_TYPE = Enum<typeof DESTINATION_TYPE>;
+
+export const INITIAL_REGISTRATION_STATUS = {
+  fetchWebexSite: false,
+  getGeoHint: false,
+  startReachability: false,
+  deviceRegister: false,
+  mercuryConnect: false,
+  checkH264Support: false,
+};

package/src/meetings/index.ts

@@ -1,5 +1,5 @@
 /* eslint no-shadow: ["error", { "allow": ["eventType"] }] */
-import {cloneDeep} from 'lodash';
+import {cloneDeep, clone} from 'lodash';
 import '@webex/internal-plugin-mercury';
 import '@webex/internal-plugin-conversation';
 import '@webex/internal-plugin-metrics';
@@ -42,6 +42,7 @@ import {
   _ON_HOLD_LOBBY_,
   _WAIT_,
   DESTINATION_TYPE,
+  INITIAL_REGISTRATION_STATUS,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import MeetingInfo from '../meeting-info';
@@ -53,7 +54,12 @@ import Request from './request';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 import MeetingCollection from './collection';
-import {MEETING_KEY, INoiseReductionEffect, IVirtualBackgroundEffect} from './meetings.types';
+import {
+  MEETING_KEY,
+  INoiseReductionEffect,
+  IVirtualBackgroundEffect,
+  MeetingRegistrationStatus,
+} from './meetings.types';
 import MeetingsUtil from './util';
 import PermissionError from '../common/errors/permission';
 import JoinWebinarError from '../common/errors/join-webinar-error';
@@ -179,6 +185,7 @@ export default class Meetings extends WebexPlugin {
   mediaHelpers: any;
   breakoutLocusForHandleLater: any;
   namespace = MEETINGS;
+  registrationStatus: MeetingRegistrationStatus;
 
   /**
    * Initializes the Meetings Plugin
@@ -785,6 +792,18 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
+  /**
+   * Executes a registration step and updates the registration status.
+   * @param {Function} step - The registration step to execute.
+   * @param {string} stepName - The name of the registration step.
+   * @returns {Promise} A promise that resolves when the step is completed.
+   */
+  executeRegistrationStep(step: () => Promise<any>, stepName: string) {
+    return step().then(() => {
+      this.registrationStatus[stepName] = true;
+    });
+  }
+
   /**
    * Explicitly sets up the meetings plugin by registering
    * the device, connecting to mercury, and listening for locus events.
@@ -795,6 +814,8 @@ export default class Meetings extends WebexPlugin {
    * @memberof Meetings
    */
   public register(deviceRegistrationOptions?: DeviceRegistrationOptions): Promise<any> {
+    this.registrationStatus = clone(INITIAL_REGISTRATION_STATUS);
+
     // @ts-ignore
     if (!this.webex.canAuthorize) {
       LoggerProxy.logger.error(
@@ -813,24 +834,39 @@ export default class Meetings extends WebexPlugin {
     }
 
     return Promise.all([
-      this.fetchUserPreferredWebexSite(),
-      this.getGeoHint(),
-      this.startReachability('registration').catch((error) => {
-        LoggerProxy.logger.error(`Meetings:index#register --> GDM error, ${error.message}`);
-      }),
-      // @ts-ignore
-      this.webex.internal.device
-        .register(deviceRegistrationOptions)
-        // @ts-ignore
-        .then(() =>
-          LoggerProxy.logger.info(
+      this.executeRegistrationStep(() => this.fetchUserPreferredWebexSite(), 'fetchWebexSite'),
+      this.executeRegistrationStep(() => this.getGeoHint(), 'getGeoHint'),
+      this.executeRegistrationStep(
+        () =>
+          this.startReachability('registration').catch((error) => {
+            LoggerProxy.logger.error(`Meetings:index#register --> GDM error, ${error.message}`);
+          }),
+        'startReachability'
+      ),
+      this.executeRegistrationStep(
+        () =>
+          // @ts-ignore
+          this.webex.internal.device
+            .register(deviceRegistrationOptions)
             // @ts-ignore
-            `Meetings:index#register --> INFO, Device registered ${this.webex.internal.device.url}`
-          )
+            .then(() => {
+              LoggerProxy.logger.info(
+                // @ts-ignore
+                `Meetings:index#register --> INFO, Device registered ${this.webex.internal.device.url}`
+              );
+            }),
+        'deviceRegister'
+      ).then(() =>
+        this.executeRegistrationStep(
+          // @ts-ignore
+          () => this.webex.internal.mercury.connect(),
+          'mercuryConnect'
         )
-        // @ts-ignore
-        .then(() => this.webex.internal.mercury.connect()),
-      MeetingsUtil.checkH264Support.call(this),
+      ),
+      this.executeRegistrationStep(
+        () => Promise.resolve(MeetingsUtil.checkH264Support.call(this)),
+        'checkH264Support'
+      ),
     ])
       .then(() => {
         this.listenForEvents();
@@ -894,6 +930,7 @@ export default class Meetings extends WebexPlugin {
             EVENT_TRIGGERS.MEETINGS_UNREGISTERED
           );
           this.registered = false;
+          this.registrationStatus = clone(INITIAL_REGISTRATION_STATUS);
         })
     );
   }

package/src/meetings/meetings.types.ts

@@ -21,3 +21,13 @@ export const MEETING_KEY = {
 } as const;
 
 export type MEETING_KEY = Enum<typeof MEETING_KEY>;
+
+// finer grained status for registration steps
+export type MeetingRegistrationStatus = {
+  fetchWebexSite: boolean;
+  getGeoHint: boolean;
+  startReachability: boolean;
+  deviceRegister: boolean;
+  mercuryConnect: boolean;
+  checkH264Support: boolean;
+};

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

@@ -37,6 +37,7 @@ import {
   LOCUSINFO,
   EVENT_TRIGGERS,
   DESTINATION_TYPE,
+  INITIAL_REGISTRATION_STATUS,
 } from '../../../../src/constants';
 import CaptchaError from '@webex/plugin-meetings/src/common/errors/captcha-error';
 import {forEach} from 'lodash';
@@ -375,21 +376,21 @@ describe('plugin-meetings', () => {
           assert.isTrue(webex.meetings.registered);
         });
 
-        it('rejects when SDK canAuthorize is false', () => {
+        it('rejects when SDK canAuthorize is false', async () => {
           webex.canAuthorize = false;
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
-        it('rejects when device.register fails', () => {
+        it('rejects when device.register fails', async () => {
           webex.canAuthorize = true;
           webex.internal.device.register = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
-        it('rejects when mercury.connect fails', () => {
+        it('rejects when mercury.connect fails', async () => {
           webex.canAuthorize = true;
           webex.internal.mercury.connect = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
         it('resolves immediately if already registered', async () => {
@@ -420,6 +421,100 @@ describe('plugin-meetings', () => {
             includeDetails: CatalogDetails.features,
           });
         });
+
+        it('updates registration status as expected', async () => {
+          const clock = sinon.useFakeTimers();
+
+          const delay = (secs) => () =>
+            new Promise((resolve) => {
+              setTimeout(resolve, secs * 1000);
+            });
+
+          let i = 1;
+          sinon.stub(webex.meetings, 'fetchUserPreferredWebexSite').callsFake(delay(i++));
+          MeetingsUtil.checkH264Support.callsFake(delay(i++));
+          webex.meetings.startReachability.callsFake(delay(i++));
+          webex.internal.device.register.callsFake(delay(i++));
+          sinon.stub(webex.meetings, 'getGeoHint').callsFake(delay(i++));
+          webex.internal.mercury.connect.callsFake(delay(i++));
+
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+
+          const registerPromise = webex.meetings.register({
+            includeDetails: CatalogDetails.features,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.fetchUserPreferredWebexSite;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: false,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: false,
+          });
+
+          await clock.tick(1000);
+          await MeetingsUtil.checkH264Support;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: false,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.startReachability;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: true,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.internal.device.register;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.getGeoHint;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: true,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(6000);
+          await webex.internal.mercury.connect;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: true,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: true,
+            checkH264Support: true,
+          });
+
+          await registerPromise;
+
+          clock.restore();
+        });
       });
 
       describe('#unregister', () => {
@@ -440,27 +535,36 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('rejects when device.unregister fails', () => {
+        it('rejects when device.unregister fails', async () => {
           webex.meetings.registered = true;
           webex.internal.device.unregister = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.unregister());
+          await assert.isRejected(webex.meetings.unregister());
         });
 
-        it('rejects when mercury.disconnect fails', () => {
+        it('rejects when mercury.disconnect fails', async () => {
           webex.meetings.registered = true;
           webex.internal.mercury.disconnect = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.unregister());
+          await assert.isRejected(webex.meetings.unregister());
         });
 
-        it('resolves immediately if already registered', (done) => {
+        it('resolves immediately if not registered', (done) => {
           webex.meetings.registered = false;
           webex.meetings.unregister().then(() => {
-            assert.notCalled(webex.internal.device.register);
-            assert.notCalled(webex.internal.mercury.connect);
+            assert.notCalled(webex.internal.device.unregister);
+            assert.notCalled(webex.internal.mercury.disconnect);
             assert.isFalse(webex.meetings.registered);
             done();
           });
         });
+
+        it('resets registration status', (done) => {
+          webex.meetings.registered = true;
+          webex.meetings.registrationStatus = {foo: 'bar'};
+          webex.meetings.unregister().then(() => {
+            assert.deepEqual(webex.meetings.registrationStatus, INITIAL_REGISTRATION_STATUS);
+            done();
+          });
+        });
       });
 
       describe('virtual background effect', () => {