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

package/src/recording-controller/index.ts

@@ -0,0 +1,315 @@
+import PermissionError from '../common/errors/permission';
+import {CONTROLS, HTTP_VERBS} from '../constants';
+import MeetingRequest from '../meeting/request';
+import RecordingAction from './enums';
+import Util from './util';
+import LoggerProxy from '../common/logs/logger-proxy';
+
+/**
+ * @description Recording manages the recording functionality of the meeting object, there should only be one instantation of recording per meeting
+ * @export
+ * @private
+ * @class Recording
+ */
+export default class RecordingController {
+  /**
+   * @instance
+   * @type {MeetingRequest}
+   * @private
+   * @memberof RecordingController
+   */
+  private request: MeetingRequest;
+
+  /**
+   * @instance
+   * @type {Array}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private displayHints: Array<string> = [];
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private serviceUrl: string;
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private sessionId: string;
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private locusUrl: string;
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private locusId: string;
+
+  /**
+   * @param {MeetingRequest} request
+   * @param {Object} options
+   * @constructor
+   * @memberof RecordingController
+   */
+  constructor(
+    request: MeetingRequest,
+    options?: {
+      serviceUrl?: string;
+      sessionId: string;
+      locusUrl: string;
+      displayHints?: Array<string>;
+    }
+  ) {
+    this.initialize(request);
+    this.set(options);
+  }
+
+  /**
+   * @param {MeetingRequest} request
+   * @param {LocusInfo} info
+   * @returns {void}
+   * @private
+   * @memberof RecordingController
+   */
+  private initialize(request: MeetingRequest) {
+    this.request = request;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public set(options?: {
+    serviceUrl?: string;
+    sessionId: string;
+    locusUrl: string;
+    displayHints?: Array<string>;
+  }) {
+    this.extract(options);
+  }
+
+  /**
+   * @param {string} url
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setLocusUrl(url: string) {
+    this.locusUrl = url;
+    this.locusId = Util.extractLocusId(this.locusUrl);
+  }
+
+  /**
+   * @param {Array} hints
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setDisplayHints(hints: Array<string>) {
+    this.displayHints = hints;
+  }
+
+  /**
+   * @param {string} id
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setSessionId(id: string) {
+    this.sessionId = id;
+  }
+
+  /**
+   * @param {string} url
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setServiceUrl(url: string) {
+    this.serviceUrl = url;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getLocusUrl() {
+    return this.locusUrl;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getLocusId() {
+    return this.locusId;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getSessionId() {
+    return this.sessionId;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getServiceUrl() {
+    return this.serviceUrl;
+  }
+
+  /**
+   * @returns {Array}
+   * @public
+   * @memberof RecordingController
+   */
+  public getDisplayHints() {
+    return this.displayHints;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @private
+   * @memberof RecordingController
+   */
+  private extract(options?: {
+    serviceUrl?: string;
+    sessionId: string;
+    locusUrl: string;
+    displayHints?: Array<string>;
+  }) {
+    this.setServiceUrl(options?.serviceUrl);
+    this.setSessionId(options?.sessionId);
+    this.setDisplayHints(options?.displayHints);
+    this.setLocusUrl(options?.locusUrl);
+  }
+
+  /**
+   * @param {RecordingAction} action
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  private recordingService(action: RecordingAction): Promise<any> {
+    // @ts-ignore
+    return this.request.request({
+      body: {
+        meetingInfo: {
+          locusSessionId: this.sessionId,
+        },
+        recording: {
+          action: action.toLowerCase(),
+        },
+      },
+      uri: `${this.serviceUrl}/loci/${this.locusId}/recording`,
+      method: HTTP_VERBS.PUT,
+    });
+  }
+
+  /**
+   * @param {RecordingAction} action
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  private recordingControls(action: RecordingAction): Promise<any> {
+    const record = Util.deriveRecordingStates(action);
+
+    LoggerProxy.logger.log(`RecordingController:index#recordingControls --> ${record}`);
+
+    // @ts-ignore
+    return this.request.request({
+      uri: `${this.locusUrl}/${CONTROLS}`,
+      body: {
+        record,
+      },
+      method: HTTP_VERBS.PATCH,
+    });
+  }
+
+  /**
+   * @param {RecordingAction} action
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  private recordingFacade(action: RecordingAction): Promise<any> {
+    LoggerProxy.logger.log(
+      `RecordingController:index#recordingFacade --> recording action [${action}]`
+    );
+
+    // assumes action is proper cased (i.e., Example)
+    if (Util?.[`canUser${action}`](this.displayHints)) {
+      if (this.serviceUrl) {
+        return this.recordingService(action);
+      }
+
+      return this.recordingControls(action);
+    }
+
+    return Promise.reject(
+      new PermissionError(`${action} recording not allowed, due to moderator property.`)
+    );
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public startRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Start);
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public stopRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Stop);
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public pauseRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Pause);
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public resumeRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Resume);
+  }
+}

package/src/recording-controller/util.ts

@@ -0,0 +1,58 @@
+import {DISPLAY_HINTS} from '../constants';
+import RecordingAction from './enums';
+
+const canUserStart = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
+
+const canUserPause = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
+
+const canUserResume = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
+
+const canUserStop = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
+
+const extractLocusId = (url: string) => {
+  return url?.split('/').pop();
+};
+
+const deriveRecordingStates = (action: RecordingAction): {recording: boolean; paused: boolean} => {
+  let recording;
+  let paused;
+
+  switch (action) {
+    case RecordingAction.Start:
+      recording = true;
+      paused = false;
+      break;
+    case RecordingAction.Stop:
+      recording = false;
+      paused = false;
+      break;
+    case RecordingAction.Resume:
+      recording = true;
+      paused = false;
+      break;
+    case RecordingAction.Pause:
+      recording = true;
+      paused = true;
+      break;
+    default:
+      throw new Error(`Recording state cannot be derived from invalid action: ${action}`);
+  }
+
+  return {
+    recording,
+    paused,
+  };
+};
+
+export default {
+  canUserStart,
+  canUserPause,
+  canUserResume,
+  canUserStop,
+  deriveRecordingStates,
+  extractLocusId,
+};

package/src/roap/request.ts

@@ -13,12 +13,14 @@ import {eventType} from '../metrics/config';
 export default class RoapRequest extends StatelessWebexPlugin {
   /**
    * Joins a meeting via ROAP
-   * @param {Object} options
+   * @param {Object} localSdp
    * @returns {Promise} returns a promise that resolves/rejects whatever the request does
    */
-
-  attachRechabilityData(localSdp) {
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
+  async attachRechabilityData(localSdp) {
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorage)
+      .catch(() => {});
 
     if (reachabilityData) {
       try {
@@ -48,6 +50,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {Boolean} options.audioMuted
    * @param {Boolean} options.videoMuted
    * @param {String} options.meetingId
+   * @param {Boolean} options.preferTranscoding
    * @returns {Promise} returns the response/failure of the request
    */
   sendRoap(options: {
@@ -76,77 +79,79 @@ export default class RoapRequest extends StatelessWebexPlugin {
 
     Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
 
-    // @ts-ignore
-    return this.webex
-      .request({
-        uri: mediaUrl,
-        method: HTTP_VERBS.PUT,
-        body: {
-          device: {
-            url: deviceUrl,
-            // @ts-ignore
-            deviceType: this.config.meetings.deviceType,
-          },
-          correlationId,
-          localMedias: [
-            {
-              localSdp: JSON.stringify(
-                this.attachRechabilityData({
-                  roapMessage,
-                  // eslint-disable-next-line no-warning-comments
-                  // TODO: check whats the need for video and audiomute
-                  audioMuted: !!options.audioMuted,
-                  videoMuted: !!options.videoMuted,
-                })
-              ),
-              mediaId: options.mediaId,
+    return this.attachRechabilityData({
+      roapMessage,
+      // eslint-disable-next-line no-warning-comments
+      // TODO: check whats the need for video and audiomute
+      audioMuted: !!options.audioMuted,
+      videoMuted: !!options.videoMuted,
+    }).then((sdpWithReachability) => {
+      // @ts-ignore
+      return this.webex
+        .request({
+          uri: mediaUrl,
+          method: HTTP_VERBS.PUT,
+          body: {
+            device: {
+              url: deviceUrl,
+              // @ts-ignore
+              deviceType: this.config.meetings.deviceType,
+            },
+            correlationId,
+            localMedias: [
+              {
+                localSdp: JSON.stringify(sdpWithReachability),
+                mediaId: options.mediaId,
+              },
+            ],
+            clientMediaPreferences: {
+              preferTranscoding: options.preferTranscoding ?? true,
             },
-          ],
-          clientMediaPreferences: {
-            preferTranscoding: options.preferTranscoding ?? true,
           },
-        },
-      })
-      .then((res) => {
-        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
-        // always it will be the first mediaConnection Object
-        const mediaConnections =
-          res.body.mediaConnections &&
-          res.body.mediaConnections.length > 0 &&
-          res.body.mediaConnections[0];
-
-        LoggerProxy.logger.info(
-          `Roap:request#sendRoap --> response:${JSON.stringify(
-            mediaConnections,
-            null,
-            2
-          )}'\n StatusCode:'${res.statusCode}`
-        );
-        const {locus} = res.body;
-
-        locus.roapSeq = options.roapMessage.seq;
-
-        return {
-          locus,
-          ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
-        };
-      })
-      .catch((err) => {
-        Metrics.postEvent({
-          event: eventType.MEDIA_RESPONSE,
-          meetingId,
-          data: {error: Metrics.parseLocusError(err, true)},
+        })
+        .then((res) => {
+          Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
+
+          // always it will be the first mediaConnection Object
+          const mediaConnections =
+            res.body.mediaConnections &&
+            res.body.mediaConnections.length > 0 &&
+            res.body.mediaConnections[0];
+
+          LoggerProxy.logger.info(
+            `Roap:request#sendRoap --> response:${JSON.stringify(
+              mediaConnections,
+              null,
+              2
+            )}'\n StatusCode:'${res.statusCode}`
+          );
+          const {locus} = res.body;
+
+          locus.roapSeq = options.roapMessage.seq;
+
+          return {
+            locus,
+            ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
+          };
+        })
+        .catch((err) => {
+          Metrics.postEvent({
+            event: eventType.MEDIA_RESPONSE,
+            meetingId,
+            data: {error: Metrics.parseLocusError(err, true)},
+          });
+          LoggerProxy.logger.error(
+            `Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`
+          );
+          LoggerProxy.logger.error(
+            `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
+              roapMessage,
+              null,
+              2
+            )} + '\\n mediaId:'${options.mediaId}`
+          );
+          throw err;
         });
-        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
-        LoggerProxy.logger.error(
-          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
-            roapMessage,
-            null,
-            2
-          )} + '\\n mediaId:'${options.mediaId}`
-        );
-        throw err;
-      });
+    });
   }
 }

package/src/roap/turnDiscovery.ts

@@ -184,6 +184,7 @@ export default class TurnDiscovery {
         audioMuted: meeting.isAudioMuted(),
         videoMuted: meeting.isVideoMuted(),
         meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
       })
       .then(({mediaConnections}) => {
         if (mediaConnections) {
@@ -216,6 +217,7 @@ export default class TurnDiscovery {
       audioMuted: meeting.isAudioMuted(),
       videoMuted: meeting.isVideoMuted(),
       meetingId: meeting.id,
+      preferTranscoding: !meeting.isMultistream,
     });
   }
 
@@ -236,19 +238,19 @@ export default class TurnDiscovery {
    *                                 media connection just after a reconnection
    * @returns {Promise}
    */
-  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean) {
+  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
     // @ts-ignore - fix type
-    const isAnyClusterReachable = meeting.webex.meetings.reachability.isAnyClusterReachable();
+    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
 
     if (isAnyClusterReachable) {
       LoggerProxy.logger.info(
         'Roap:turnDiscovery#doTurnDiscovery --> reachability has not failed, skipping TURN discovery'
       );
 
-      return Promise.resolve({
+      return {
         turnServerInfo: undefined,
         turnDiscoverySkippedReason: 'reachability',
-      });
+      };
     }
 
     // @ts-ignore - fix type
@@ -257,7 +259,7 @@ export default class TurnDiscovery {
         'Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it'
       );
 
-      return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'});
+      return {turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'};
     }
 
     return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
@@ -283,7 +285,7 @@ export default class TurnDiscovery {
           stack: e.stack,
         });
 
-        return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+        return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
       });
   }
 }

package/src/statsAnalyzer/index.ts

@@ -1,7 +1,7 @@
 /* eslint-disable prefer-destructuring */
 
 import {cloneDeep} from 'lodash';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState} from '@webex/internal-media-core';
 
 import EventsScope from '../common/events/events-scope';
 import {
@@ -335,7 +335,7 @@ export class StatsAnalyzer extends EventsScope {
    *
    * @private
    * @memberof StatsAnalyzer
-   * @param {MC.RoapMediaConnection} mediaConnection
+   * @param {RoapMediaConnection} mediaConnection
    * @returns {void}
    */
   updateMediaConnection(mediaConnection: any) {
@@ -347,7 +347,7 @@ export class StatsAnalyzer extends EventsScope {
    *
    * @public
    * @memberof StatsAnalyzer
-   * @param {MC.RoapMediaConnection} mediaConnection
+   * @param {RoapMediaConnection} mediaConnection
    * @returns {Promise}
    */
   public startAnalyzer(mediaConnection: any) {
@@ -820,7 +820,7 @@ export class StatsAnalyzer extends EventsScope {
 
     if (
       this.mediaConnection &&
-      this.mediaConnection.getConnectionState() === MC.ConnectionState.Failed
+      this.mediaConnection.getConnectionState() === ConnectionState.Failed
     ) {
       LoggerProxy.logger.trace(
         'StatsAnalyzer:index#getStatsAndParse --> media connection is in failed state'

package/src/statsAnalyzer/mqaUtil.ts

@@ -26,6 +26,7 @@ export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSen
 
   // @ts-ignore
   audioReceiver.streams[0].common.maxRtpJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
   audioReceiver.streams[0].common.meanRtpJitter =
     mean(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
@@ -72,6 +73,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
 
   // @ts-ignore
   audioSender.common.maxRemoteJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
   audioSender.common.meanRemoteJitter =
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -96,6 +98,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
 
   // @ts-ignore
   audioSender.common.maxRoundTripTime =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
   audioSender.common.meanRoundTripTime =
     mean(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
@@ -152,6 +155,7 @@ export const getVideoReceiverMqa = ({
 
   // @ts-ignore
   videoReceiver.common.maxRemoteJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
   videoReceiver.common.meanRemoteJitter =
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -217,6 +221,7 @@ export const getVideoSenderMqa = ({
 
   // @ts-ignore
   videoSender.common.maxRemoteJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
   videoSender.common.meanRemoteJitter =
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -239,6 +244,7 @@ export const getVideoSenderMqa = ({
 
   // @ts-ignore
   videoSender.common.maxRoundTripTime =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
   videoSender.common.meanRoundTripTime =
     mean(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;