feat: WxCC SDK Subscribe Notifications and establish Mercury Connection

docs/samples/contact-center/app.js

@@ -104,7 +104,7 @@ function initWebex(e) {
 credentialsFormElm.addEventListener('submit', initWebex);
 
 function register() {
-    webex.cc.register(true).then((data) => {
+    webex.cc.register().then((data) => {
         console.log('Event subscription successful: ', data);
     }).catch(() => {
         console.log('Event subscription failed');

packages/@webex/internal-plugin-mercury/src/mercury.js

@@ -217,6 +217,8 @@ const Mercury = WebexPlugin.extend({
           token: token.toString(),
           trackingId: `${this.webex.sessionId}_${Date.now()}`,
           logger: this.logger,
+          authorizationRequired: this.config.authorizationRequired ?? true,
+          acknowledgementRequired: this.config.acknowledgementRequired ?? true,
         };
 
         // if the consumer has supplied request options use them
@@ -399,8 +401,11 @@ const Mercury = WebexPlugin.extend({
   },
 
   _getEventHandlers(eventType) {
-    const [namespace, name] = eventType.split('.');
     const handlers = [];
+    if (!eventType) {
+      return handlers;
+    }
+    const [namespace, name] = eventType.split('.');
 
     if (!this.webex[namespace] && !this.webex.internal[namespace]) {
       return handlers;
@@ -511,13 +516,15 @@ const Mercury = WebexPlugin.extend({
       )
       .then(() => {
         this._emit('event', event.data);
-        const [namespace] = data.eventType.split('.');
+        if (data.eventType) {
+          const [namespace] = data.eventType.split('.');
 
-        if (namespace === data.eventType) {
-          this._emit(`event:${namespace}`, envelope);
-        } else {
-          this._emit(`event:${namespace}`, envelope);
-          this._emit(`event:${data.eventType}`, envelope);
+          if (namespace === data.eventType) {
+            this._emit(`event:${namespace}`, envelope);
+          } else {
+            this._emit(`event:${namespace}`, envelope);
+            this._emit(`event:${data.eventType}`, envelope);
+          }
         }
       })
       .catch((reason) => {

packages/@webex/internal-plugin-mercury/src/socket/socket-base.js

@@ -179,6 +179,8 @@ export default class Socket extends EventEmitter {
    * @param {string} options.token (required)
    * @param {string} options.trackingId (required)
    * @param {Logger} options.logger (required)
+   * @param {boolean} options.authorizationRequired
+   * @param {boolean} options.acknowledgementRequired
    * @param {string} options.logLevelToken
    * @returns {Promise}
    */
@@ -210,7 +212,18 @@ export default class Socket extends EventEmitter {
         options
       );
 
-      Object.keys(options).forEach((key) => {
+      // Destructure and set default values for authorizationRequired and acknowledgementRequired
+      const {
+        authorizationRequired = true,
+        acknowledgementRequired = true,
+        ...remainingOptions
+      } = options;
+
+      this.authorizationRequired = authorizationRequired;
+      this.acknowledgementRequired = acknowledgementRequired;
+
+      // Assign the remaining options to the instance
+      Object.keys(remainingOptions).forEach((key) => {
         Reflect.defineProperty(this, key, {
           enumerable: false,
           value: options[key],
@@ -250,13 +263,18 @@ export default class Socket extends EventEmitter {
 
       socket.onopen = () => {
         this.logger.info(`socket,${this._domain}: connected`);
-        this._authorize()
-          .then(() => {
-            this.logger.info(`socket,${this._domain}: authorized`);
-            socket.onclose = this.onclose;
-            resolve();
-          })
-          .catch(reject);
+        // Added the "authorizationRequired" condition to bypass the "_authorize" in case of the contact center context, in which case it is configured as false.
+        if (this.authorizationRequired) {
+          this._authorize()
+            .then(() => {
+              this.logger.info(`socket,${this._domain}: authorized`);
+              socket.onclose = this.onclose;
+              resolve();
+            })
+            .catch(reject);
+        } else {
+          this._ping();
+        }
       };
 
       socket.onerror = (event) => {
@@ -310,9 +328,13 @@ export default class Socket extends EventEmitter {
       // modified and we don't actually care about anything but the data property
       const processedEvent = {data};
 
-      this._acknowledge(processedEvent);
-      if (data.type === 'pong') {
-        this.emit('pong', processedEvent);
+      // Added the "acknowledgementRequired" condition to bypass the "_acknowledge" in case of the contact center context, in which case it is configured as false.
+      if (this.acknowledgementRequired) {
+        this._acknowledge(processedEvent);
+      }
+      if (data.type === 'pong' || data.type === 'ping') {
+        // added above ping condition to handle pong messages of contact center where type is 'ping' instead of 'pong'
+        this.emit('pong', {...processedEvent, type: 'pong'});
       } else {
         this.emit('message', processedEvent);
       }

packages/@webex/internal-plugin-mercury/test/unit/spec/mercury.js

@@ -713,6 +713,21 @@ describe('plugin-mercury', () => {
           return res;
         });
       });
+
+      it('_onmessage without eventType', () => {
+        sinon.spy(mercury, '_getEventHandlers');
+        sinon.spy(mercury, '_emit');
+        const event = {data: {data: {eventType: undefined, mydata: 'some data'}}};
+        mercury.logger.error.restore();
+        sinon.stub(mercury.logger, 'error');
+        return Promise.resolve(mercury._onmessage(event)).then(() => {
+          assert.calledWith(mercury._getEventHandlers, undefined);
+          assert.calledWith(mercury._emit, 'event', event.data);
+          assert.notCalled(mercury.logger.error);
+          mercury._emit.restore();
+          mercury._getEventHandlers.restore();
+        });
+      });
     });
 
     describe('#_applyOverrides()', () => {

packages/@webex/internal-plugin-mercury/test/unit/spec/socket.js

@@ -139,6 +139,7 @@ describe('plugin-mercury', () => {
         ));
 
       it('accepts a logLevelToken option', () => {
+        const acknowledgeSpy = sinon.spy(socket, '_acknowledge');
         const promise = socket.open('ws://example.com', {
           forceCloseDelay: mockoptions.forceCloseDelay,
           pingInterval: mockoptions.pingInterval,
@@ -147,6 +148,7 @@ describe('plugin-mercury', () => {
           token: 'mocktoken',
           trackingId: 'mocktrackingid',
           logLevelToken: 'mocklogleveltoken',
+          acknowledgementRequired: true,
         });
 
         mockWebSocket.readyState = 1;
@@ -162,9 +164,83 @@ describe('plugin-mercury', () => {
         });
 
         return promise.then(() => {
+          assert.called(acknowledgeSpy);
           assert.equal(socket.logLevelToken, 'mocklogleveltoken');
         });
       });
+
+      it('accepts acknowledgementRequired option as false and skip acknowledge', () => {
+        const acknowledgeSpy = sinon.spy(socket, '_acknowledge');
+        const promise = socket.open('ws://example.com', {
+          forceCloseDelay: mockoptions.forceCloseDelay,
+          pingInterval: mockoptions.pingInterval,
+          pongTimeout: mockoptions.pongTimeout,
+          logger: console,
+          token: 'mocktoken',
+          trackingId: 'mocktrackingid',
+          logLevelToken: 'mocklogleveltoken',
+          acknowledgementRequired: false,
+        });
+
+        mockWebSocket.readyState = 1;
+        mockWebSocket.emit('open');
+
+        mockWebSocket.emit('message', {
+          data: JSON.stringify({
+            id: uuid.v4(),
+            data: {
+              eventType: 'mercury.buffer_state',
+            },
+          }),
+        });
+
+        return promise.then(() => {
+          assert.notCalled(acknowledgeSpy);
+          assert.equal(socket.logLevelToken, 'mocklogleveltoken');
+        });
+      });
+
+      it('accepts authorizationRequired option as false and skip authorize', () => {
+        const s = new Socket();
+        const authorizeSpy = sinon.spy(socket, '_authorize');
+        socket.open('ws://example.com', {
+          forceCloseDelay: mockoptions.forceCloseDelay,
+          pingInterval: mockoptions.pingInterval,
+          pongTimeout: mockoptions.pongTimeout,
+          logger: console,
+          token: 'mocktoken',
+          trackingId: 'mocktrackingid',
+          logLevelToken: 'mocklogleveltoken',
+          authorizationRequired: false,
+        });
+
+          mockWebSocket.readyState = 1;
+          mockWebSocket.emit('open');
+
+          assert.notCalled(authorizeSpy);
+          assert.called(socket._ping);
+        });
+
+      it('accepts authorizationRequired option as true and calles authorize', () => {
+        const s = new Socket();
+        const authorizeSpy = sinon.spy(socket, '_authorize');
+        socket.open('ws://example.com', {
+          forceCloseDelay: mockoptions.forceCloseDelay,
+          pingInterval: mockoptions.pingInterval,
+          pongTimeout: mockoptions.pongTimeout,
+          logger: console,
+          token: 'mocktoken',
+          trackingId: 'mocktrackingid',
+          logLevelToken: 'mocklogleveltoken',
+          authorizationRequired: true,
+        });
+
+          mockWebSocket.readyState = 1;
+          mockWebSocket.emit('open');
+
+          assert.called(authorizeSpy);
+          assert.called(socket._ping);
+      });
     });
 
     describe('#binaryType', () => {

packages/@webex/plugin-cc/src/WebSocket/IWebSocket.ts

@@ -0,0 +1,13 @@
+import {WebSocketEvent} from '../types';
+
+interface IWebSocket {
+  on(event: string, callback: (event: WebSocketEvent) => void): void;
+  off(event: string, callback: (event: WebSocketEvent) => void): void;
+  subscribeAndConnect(params: {datachannelUrl: string; body: object}): Promise<void>;
+  isConnected(): boolean;
+  disconnectWebSocket(): Promise<void>;
+  getSubscriptionId(): string | undefined;
+  getDatachannelUrl(): string | undefined;
+}
+
+export default IWebSocket;