@webex/plugin-meetings 3.0.0-beta.16 → 3.0.0-beta.161

package/dist/types/transcription/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @description Meeting Webex assistance transcription feature.
+ * @exports
+ * @class Transcription
+ */
+export default class Transcription {
+    webSocketUrl: any;
+    sessionID: any;
+    members: any;
+    memberCSIs: any;
+    webSocket: any;
+    /**
+     * @param {string} webSocketUrl
+     * @param {sessionID} sessionId
+     * @param {object} members
+     * @constructor
+     * @memberof Transcription
+     */
+    constructor(webSocketUrl: string, sessionId: any, members: object);
+    /**
+     * open the Low Latency Mercury connection
+     * An event parameter will be send to the callback.
+     *
+     * @param {string} token
+     * @param {string} sessionID
+     * @returns {void}
+     */
+    connect(token: string): void;
+    /**
+     * Sets callback to invoke when the web socket connection is closed.
+     *
+     * @param {Function} callback
+     * @returns {void}
+     */
+    onCloseSocket(callback: any): void;
+    /**
+     * Sets callback to invoke when a web socket connection error occurs.
+     * An event parameter will be send to the callback.
+     *
+     * @param {Function} callback
+     * @returns {void}
+     */
+    onErrorSocket(callback: any): void;
+    /**
+     * Get current speaker from the given csis payload and update the global csis map
+     *
+     * @private
+     * @param {object} csis
+     * @returns {object}
+     */
+    private getSpeaker;
+    /**
+     * Sends transcription data to given callback as it arrives.
+     *
+     * @param {Function} callback
+     * @returns {void}
+     */
+    subscribe(callback: any): void;
+    /**
+     * Close the LLM web socket connection
+     * @returns {void}
+     */
+    closeSocket(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.161",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -12,6 +12,7 @@
     "Taymoor Khan <taykhan@cisco.com>"
   ],
   "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
   "devMain": "src/index.js",
   "repository": {
     "type": "git",
@@ -27,32 +28,38 @@
       "envify"
     ]
   },
+  "scripts": {
+    "build": "yarn run -T tsc --declaration true --declarationDir ./dist/types"
+  },
   "devDependencies": {
-    "@webex/plugin-meetings": "3.0.0-beta.16",
-    "@webex/test-helper-chai": "3.0.0-beta.16",
-    "@webex/test-helper-mocha": "3.0.0-beta.16",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.16",
-    "@webex/test-helper-retry": "3.0.0-beta.16",
-    "@webex/test-helper-test-users": "3.0.0-beta.16",
+    "@webex/plugin-meetings": "3.0.0-beta.161",
+    "@webex/test-helper-chai": "3.0.0-beta.161",
+    "@webex/test-helper-mocha": "3.0.0-beta.161",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.161",
+    "@webex/test-helper-retry": "3.0.0-beta.161",
+    "@webex/test-helper-test-users": "3.0.0-beta.161",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
     "sinon": "^9.2.4",
-    "typed-emitter": "^2.1.0"
+    "typed-emitter": "^2.1.0",
+    "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.16",
-    "@webex/internal-media-core": "^0.0.17-beta",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.16",
-    "@webex/internal-plugin-device": "3.0.0-beta.16",
-    "@webex/internal-plugin-llm": "3.0.0-beta.16",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.16",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.16",
-    "@webex/internal-plugin-support": "3.0.0-beta.16",
-    "@webex/internal-plugin-user": "3.0.0-beta.16",
-    "@webex/plugin-people": "3.0.0-beta.16",
-    "@webex/plugin-rooms": "3.0.0-beta.16",
-    "@webex/webex-core": "3.0.0-beta.16",
+    "@webex/common": "3.0.0-beta.161",
+    "@webex/internal-media-core": "1.38.6",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.161",
+    "@webex/internal-plugin-device": "3.0.0-beta.161",
+    "@webex/internal-plugin-llm": "3.0.0-beta.161",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.161",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.161",
+    "@webex/internal-plugin-support": "3.0.0-beta.161",
+    "@webex/internal-plugin-user": "3.0.0-beta.161",
+    "@webex/media-helpers": "3.0.0-beta.161",
+    "@webex/plugin-people": "3.0.0-beta.161",
+    "@webex/plugin-rooms": "3.0.0-beta.161",
+    "@webex/webex-core": "3.0.0-beta.161",
+    "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
     "dotenv": "^4.0.0",
@@ -62,6 +69,6 @@
     "lodash": "^4.17.21",
     "sdp-transform": "^2.12.0",
     "uuid": "^3.3.2",
-    "webrtc-adapter": "^7.7.0"
+    "webrtc-adapter": "^8.1.2"
   }
 }

package/src/annotation/annotation.types.ts

@@ -0,0 +1,52 @@
+import {ANNOTATION_POLICY} from './constants';
+
+/**
+ * Type for an StrokeData Object
+ */
+type StrokeData = {
+  deviceId: string;
+  toUserId: string;
+  requesterId: string;
+  content: string;
+  shareInstanceId: string;
+  encryptionKeyUrl: string;
+  version: string;
+};
+
+type RequestData = {
+  toUserId: string;
+  toDeviceUrl: string;
+  shareInstanceId: string;
+};
+
+type CommandRequestBody = {
+  actionType: string;
+  resourceType: string;
+  shareInstanceId: string;
+  receivers?: any[];
+};
+/**
+ * Type for an annotation Object include annotation version and privilege
+ */
+type AnnotationInfo = {
+  version: string;
+  policy: ANNOTATION_POLICY;
+};
+
+interface IAnnotationChannel {
+  // === below is for presenter
+  acceptRequest: (approval) => undefined | Promise<void>;
+  declineRequest: (approval) => undefined | Promise<void>;
+  closeAnnotation: (requestData: RequestData) => undefined | Promise<void>;
+  // change annotation privilege
+  changeAnnotationOptions: (remoteShareUrl, annotationInfo) => undefined | Promise<void>;
+  // === below is for attendee
+  approveAnnotation: (requestData: RequestData) => undefined | Promise<void>;
+  cancelApproveAnnotation: (requestData: RequestData, approval) => undefined | Promise<void>;
+  sendStrokeData: (strokeData: StrokeData) => void;
+  // =====
+  approvalUrlUpdate: (approvalUrl: string) => void;
+  locusUrlUpdate: (locusUrl: string) => void;
+}
+
+export type {StrokeData, RequestData, CommandRequestBody, IAnnotationChannel, AnnotationInfo};

package/src/annotation/constants.ts

@@ -0,0 +1,36 @@
+export const EVENT_TRIGGERS = {
+  ANNOTATION_STROKE_DATA: 'annotation:strokeData',
+  ANNOTATION_COMMAND: 'annotation:command',
+};
+export const ANNOTATION_RESOURCE_TYPE = 'AnnotationOnShare';
+export const ANNOTATION_RELAY_TYPES = {
+  ANNOTATION_CLIENT: 'annotation.client',
+};
+
+export const ANNOTATION_STATUS = {
+  NO_ANNOTATION: 'NO_ANNOTATION',
+  RUNNING_ANNOTATION: 'RUNNING_ANNOTATION',
+};
+
+export enum ANNOTATION_POLICY {
+  ANYONE_CAN_ANNOTATE = 'AnyoneCanAnnotate',
+  APPROVAL = 'Approval',
+  ANNOTATION_NOT_ALLOWED = 'AnnotationNotAllowed',
+}
+
+export const ANNOTATION_REQUEST_TYPE = {
+  ANNOTATION_MESSAGE: 'annotation_message',
+};
+
+export const enum ANNOTATION_ACTION_TYPE {
+  REQUESTED = 'REQUESTED',
+  ACCEPTED = 'ACCEPTED',
+  DECLINED = 'DECLINED',
+  OFFERED = 'OFFERED',
+  CANCELED = 'CANCELED',
+  EXPIRED = 'EXPIRED',
+  REVOKED = 'REVOKED',
+  CLOSED = 'CLOSED',
+}
+
+export const ANNOTATION = 'annotation';

package/src/annotation/index.ts

@@ -0,0 +1,343 @@
+import uuid from 'uuid';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import {WebexPlugin, config} from '@webex/webex-core';
+import TriggerProxy from '../common/events/trigger-proxy';
+
+import {
+  EVENT_TRIGGERS,
+  ANNOTATION_RELAY_TYPES,
+  ANNOTATION,
+  ANNOTATION_REQUEST_TYPE,
+  ANNOTATION_ACTION_TYPE,
+  ANNOTATION_RESOURCE_TYPE,
+} from './constants';
+
+import {StrokeData, RequestData, IAnnotationChannel, CommandRequestBody} from './annotation.types';
+import {HTTP_VERBS} from '../constants';
+
+/**
+ * @description Annotation to handle LLM and Mercury message and locus API
+ * @class
+ */
+class AnnotationChannel extends WebexPlugin implements IAnnotationChannel {
+  namespace = ANNOTATION;
+
+  private seqNum: number;
+
+  hasSubscribedToEvents: boolean;
+
+  approvalUrl: string;
+  locusUrl: string;
+  deviceUrl: string;
+
+  /**
+   * Initializes annotation module
+   */
+  constructor(...args) {
+    super(...args);
+    this.seqNum = 1;
+  }
+
+  /**
+   * Process Stroke Data
+   * @param {object}  data
+   * @returns {void}
+   */
+  private processStrokeMessage(data) {
+    const {request} = data;
+    this.decryptContent(request.value.encryptionKeyUrl, request.value.content).then(
+      (decryptedContent) => {
+        request.value.content = decryptedContent;
+        TriggerProxy.trigger(
+          this,
+          {
+            file: 'annotation',
+            function: 'processStrokeMessage',
+          },
+          EVENT_TRIGGERS.ANNOTATION_STROKE_DATA,
+          {
+            payload: data,
+          }
+        );
+      }
+    );
+  }
+
+  /** bind all events from mercury
+   * @param {Object} e
+   * @returns {undefined}
+   */
+  private eventCommandProcessor(e) {
+    if (
+      e?.data?.eventType === 'locus.approval_request' &&
+      e?.data?.approval?.resourceType === ANNOTATION_RESOURCE_TYPE &&
+      e?.data?.approval?.actionType
+    ) {
+      TriggerProxy.trigger(
+        this,
+        {
+          file: 'annotation',
+          function: 'approval_request',
+        },
+        EVENT_TRIGGERS.ANNOTATION_COMMAND,
+        {
+          type: e.data.approval.actionType,
+          payload: e.data.approval,
+        }
+      );
+    }
+  }
+
+  /** bind all events from llm
+   * @param {Object} e
+   * @returns {undefined}
+   */
+  private eventDataProcessor(e) {
+    switch (e?.data?.relayType) {
+      case ANNOTATION_RELAY_TYPES.ANNOTATION_CLIENT:
+        this.processStrokeMessage(e.data);
+        break;
+      default:
+        break;
+    }
+  }
+
+  /**
+   * Listen to websocket messages
+   * @returns {undefined}
+   */
+  private listenToEvents() {
+    if (!this.hasSubscribedToEvents) {
+      // @ts-ignore
+      this.webex.internal.mercury.on(
+        'event:locus.approval_request',
+        this.eventCommandProcessor,
+        this
+      );
+      // @ts-ignore
+      this.webex.internal.llm.on('event:relay.event', this.eventDataProcessor, this);
+      this.hasSubscribedToEvents = true;
+    }
+  }
+
+  /**
+   * set locusUrl
+   * @param {string} locusUrl
+   * @returns {void}
+   */
+  public locusUrlUpdate(locusUrl: string) {
+    this.locusUrl = locusUrl;
+    this.listenToEvents();
+  }
+
+  /**
+   * set approved url
+   * @param {string} approvalUrl
+   * @returns {void}
+   */
+  public approvalUrlUpdate(approvalUrl: string) {
+    this.approvalUrl = approvalUrl;
+  }
+
+  /**
+   * accept request
+   * @param {object} approval
+   * @returns {Promise}
+   */
+  public acceptRequest(approval) {
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      url: approval.url,
+      body: {
+        resourceType: ANNOTATION_RESOURCE_TYPE,
+        actionType: ANNOTATION_ACTION_TYPE.ACCEPTED,
+      },
+    });
+  }
+
+  /**
+   * presenter declined request annotation
+   * @param {approval} approval
+   * @returns {Promise}
+   */
+  public declineRequest(approval) {
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      url: approval.url,
+      body: {
+        resourceType: ANNOTATION_RESOURCE_TYPE,
+        actionType: ANNOTATION_ACTION_TYPE.DECLINED,
+      },
+    });
+  }
+
+  /**
+   * request approved annotation
+   * @param {RequestData} requestData
+   * @returns {Promise}
+   */
+  public approveAnnotation(requestData: RequestData) {
+    return this.sendAnnotationAction(ANNOTATION_ACTION_TYPE.REQUESTED, requestData);
+  }
+
+  /**
+   * cancel approved annotation
+   * @param {object} requestData
+   * @param {object} approval
+   * @returns {Promise}
+   */
+  public cancelApproveAnnotation(requestData: RequestData, approval) {
+    const body: CommandRequestBody = {
+      actionType: ANNOTATION_ACTION_TYPE.CANCELED,
+      resourceType: 'AnnotationOnShare',
+      shareInstanceId: requestData.shareInstanceId,
+    };
+
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      url: `${approval.url}`,
+      body,
+    });
+  }
+
+  /**
+   * close annotation
+   * @param {object} requestData
+   * @returns {Promise}
+   */
+  public closeAnnotation(requestData: RequestData) {
+    return this.sendAnnotationAction(ANNOTATION_ACTION_TYPE.CLOSED, requestData);
+  }
+
+  /**
+   * send annotation command
+   * @param {ANNOTATION_ACTION_TYPE} actionType
+   * @param {RequestData} requestData
+   * @returns {Promise}
+   */
+  private sendAnnotationAction = async (
+    actionType: ANNOTATION_ACTION_TYPE,
+    requestData: RequestData
+  ): Promise<void> => {
+    const body: CommandRequestBody = {
+      actionType,
+      resourceType: 'AnnotationOnShare',
+      shareInstanceId: requestData.shareInstanceId,
+    };
+    if (requestData?.toUserId) {
+      body.receivers = [{participantId: requestData.toUserId, deviceUrl: requestData.toDeviceUrl}];
+    }
+
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.POST,
+      url: `${this.approvalUrl}`,
+      body,
+    });
+  };
+
+  /**
+   * decrypt data
+   * @param {string} encryptionKeyUrl
+   * @param {string} content encrypted content
+   * @returns {string} decrypted content
+   */
+  private decryptContent = (encryptionKeyUrl: string, content: string): Promise<any> => {
+    // @ts-ignore
+    return this.webex.internal.encryption.decryptText(encryptionKeyUrl, content).then((res) => {
+      return res;
+    });
+  };
+
+  /**
+   * encrypt data
+   * @param {string} encryptionKeyUrl
+   * @param {string} content original content
+   * @returns {string} encrypted content
+   */
+  private encryptContent = (encryptionKeyUrl: string, content: string): Promise<any> => {
+    // @ts-ignore
+    return this.webex.internal.encryption.encryptText(encryptionKeyUrl, content).then((res) => {
+      return res;
+    });
+  };
+
+  /**
+   * Sends stroke data to presenter
+   * @param {StrokeData} strokeData
+   * @returns {void}
+   */
+  public sendStrokeData = (strokeData: StrokeData): void => {
+    // @ts-ignore
+    if (!this.webex.internal.llm.isConnected()) return;
+    this.encryptContent(strokeData.encryptionKeyUrl, strokeData.content).then(
+      (encryptedContent) => {
+        this.publishEncrypted(encryptedContent, strokeData);
+      }
+    );
+  };
+
+  /**
+   * Change annotation options
+   * @param {remoteShareUrl} remoteShareUrl
+   * @param {annotationInfo} annotationInfo
+   * @returns {Promise}
+   */
+  public changeAnnotationOptions(remoteShareUrl, annotationInfo) {
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.PATCH,
+      url: remoteShareUrl,
+      body: annotationInfo,
+    });
+  }
+
+  /**
+   * private encrypted the strokes data
+   * @param {string} encryptedContent
+   * @param {StrokeData} strokeData
+   * @returns {void}
+   */
+  private publishEncrypted(encryptedContent: string, strokeData: StrokeData) {
+    const data = {
+      id: `${this.seqNum}`,
+      type: 'publishRequest',
+      recipients: {
+        // @ts-ignore
+        route: this.webex.internal.llm.getBinding(),
+      },
+      headers: {
+        to: strokeData.toUserId,
+      },
+      data: {
+        eventType: 'relay.event',
+        relayType: ANNOTATION_RELAY_TYPES.ANNOTATION_CLIENT,
+        request: {
+          value: {
+            type: ANNOTATION_REQUEST_TYPE.ANNOTATION_MESSAGE,
+            content: encryptedContent,
+            deviceId: strokeData.deviceId,
+            seq: this.seqNum,
+            requesterId: strokeData.requesterId,
+            version: strokeData.version,
+            shareInstanceId: strokeData.shareInstanceId,
+            encryptionKeyUrl: strokeData.encryptionKeyUrl,
+          },
+        },
+      },
+      trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      timestamp: new Date().getTime(),
+      sequenceNumber: this.seqNum,
+      filterMessage: false,
+    };
+
+    // @ts-ignore
+    this.webex.internal.llm.socket.send(data);
+    this.seqNum += 1;
+  }
+}
+
+export default AnnotationChannel;