@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.300

package/src/reconnection-manager/{index.js → index.ts}

@@ -13,14 +13,14 @@ import {
   SHARE_STOPPED_REASON,
   _CALL_,
   _LEFT_,
-  _ID_
+  _ID_,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
-import {eventType, reconnection, errorObjects} from '../metrics/config';
-import Media from '../media';
 import Metrics from '../metrics';
+import Meeting from '../meeting';
+import {MediaRequestManager} from '../multistream/mediaRequestManager';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -37,6 +37,8 @@ class NeedsRetryError extends Error {}
  * @extends {Error}
  */
 class NeedsRejoinError extends Error {
+  wasSharing: any;
+
   /**
    * Creates an instance of NeedsRejoinError.
    * @param {Object} params
@@ -44,7 +46,14 @@ class NeedsRejoinError extends Error {
    * @param {Error} params.error
    * @memberof NeedsRejoinError
    */
-  constructor({wasSharing, error = new Error('Meeting needs to be rejoined')}) {
+  constructor({
+    wasSharing,
+    error = new Error('Meeting needs to be rejoined'),
+  }: {
+    wasSharing?: boolean;
+    error?: Error;
+  }) {
+    // @ts-ignore
     super(error);
 
     this.wasSharing = wasSharing;
@@ -54,12 +63,21 @@ class NeedsRejoinError extends Error {
 /**
  * @export
  * @class ReconnectionManager
-*/
+ */
 export default class ReconnectionManager {
+  autoRejoinEnabled: any;
+  iceState: any;
+  maxRejoinAttempts: any;
+  meeting: any;
+  rejoinAttempts: any;
+  shareStatus: any;
+  status: any;
+  tryCount: any;
+  webex: any;
   /**
    * @param {Meeting} meeting
    */
-  constructor(meeting) {
+  constructor(meeting: Meeting) {
     /**
      * Stores ICE reconnection state data.
      *
@@ -72,7 +90,8 @@ export default class ReconnectionManager {
       disconnected: false,
       resolve: () => {},
       timer: undefined,
-      timeoutDuration: meeting.config.reconnection.iceReconnectionTimeout
+      // @ts-ignore
+      timeoutDuration: meeting.config.reconnection.iceReconnectionTimeout,
     };
 
     /**
@@ -80,23 +99,24 @@ export default class ReconnectionManager {
      * @type {String}
      * @private
      * @memberof ReconnectionManager
-    */
+     */
     this.status = RECONNECTION.STATE.DEFAULT_STATUS;
     /**
      * @instance
      * @type {Number}
      * @private
      * @memberof ReconnectionManager
-    */
+     */
     this.tryCount = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
     /**
      * @instance
      * @type {Object}
      * @private
      * @memberof ReconnectionManager
-    */
+     */
     // TODO : change this logic to not save the meeting instance
     // It gets complicated when meeting ends on remote side , We have a old meeting instance which is not up to date
+    // @ts-ignore
     this.webex = meeting.webex;
     /**
      * @instance
@@ -108,11 +128,12 @@ export default class ReconnectionManager {
     // try moving this to meetings collection
     this.meeting = meeting;
 
+    // @ts-ignore
     this.maxRejoinAttempts = meeting.config.reconnection.maxRejoinAttempts;
     this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
+    // @ts-ignore
     this.autoRejoinEnabled = meeting.config.reconnection.autoRejoin;
 
-
     // Make sure reconnection state is in default
     this.reset();
   }
@@ -140,7 +161,7 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  iceReconnected() {
+  public iceReconnected() {
     if (this.iceState.disconnected) {
       LoggerProxy.logger.log('ReconnectionManager:index#iceReconnected --> ice has reconnected');
 
@@ -160,20 +181,23 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  waitForIceReconnect() {
+  public waitForIceReconnect() {
     if (!this.iceState.disconnected) {
-      LoggerProxy.logger.log('ReconnectionManager:index#waitForIceReconnect --> waiting for ice reconnect');
+      LoggerProxy.logger.log(
+        'ReconnectionManager:index#waitForIceReconnect --> waiting for ice reconnect'
+      );
 
       this.iceState.disconnected = true;
 
-      return new Promise((resolve, reject) => {
+      return new Promise<void>((resolve, reject) => {
         this.iceState.timer = setTimeout(() => {
           if (this.iceState.disconnected === false) {
             resolve();
-          }
-          else {
+          } else {
             this.iceState.disconnected = false;
-            reject(new Error(`ice reconnection did not occur in ${this.iceState.timeoutDuration}ms`));
+            reject(
+              new Error(`ice reconnection did not occur in ${this.iceState.timeoutDuration}ms`)
+            );
           }
         }, this.iceState.timeoutDuration);
 
@@ -190,7 +214,7 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  reset() {
+  public reset() {
     this.status = RECONNECTION.STATE.DEFAULT_STATUS;
     this.tryCount = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
     this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
@@ -201,11 +225,36 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  cleanUp() {
+  public cleanUp() {
     this.reset();
     this.meeting = null;
   }
 
+  /**
+   * Stop the local share stream.
+   *
+   * @param {string} reason a {@link SHARE_STOPPED_REASON}
+   * @returns {undefined}
+   * @private
+   * @memberof ReconnectionManager
+   */
+  private async stopLocalShareStream(reason: string) {
+    await this.meeting.unpublishStreams([
+      this.meeting.mediaProperties.shareVideoStream,
+      this.meeting.mediaProperties.shareAudioStream,
+    ]);
+    Trigger.trigger(
+      this.meeting,
+      {
+        file: 'reconnection-manager/index',
+        function: 'stopLocalShareStream',
+      },
+      EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+      {
+        reason,
+      }
+    );
+  }
 
   /**
    * @public
@@ -213,7 +262,7 @@ export default class ReconnectionManager {
    * @returns {Boolean} true if reconnection operation is in progress
    */
   isReconnectInProgress() {
-    return (this.status === RECONNECTION.STATE.IN_PROGRESS);
+    return this.status === RECONNECTION.STATE.IN_PROGRESS;
   }
 
   /**
@@ -222,7 +271,7 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  validate() {
+  private validate() {
     if (this.meeting.config.reconnection.enabled) {
       if (
         this.status === RECONNECTION.STATE.DEFAULT_STATUS ||
@@ -231,7 +280,9 @@ export default class ReconnectionManager {
         return true;
       }
 
-      LoggerProxy.logger.info('ReconnectionManager:index#validate --> Reconnection already in progress.');
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#validate --> Reconnection already in progress.'
+      );
 
       throw new ReconnectInProgress('Reconnection already in progress.');
     }
@@ -250,39 +301,65 @@ export default class ReconnectionManager {
    * @public
    * @memberof ReconnectionManager
    */
-  async reconnect({networkDisconnect = false, networkRetry = false} = {}) {
-    LoggerProxy.logger.info(`ReconnectionManager:index#reconnect --> Reconnection start for meeting ${this.meeting.id}.`);
+  public async reconnect({
+    networkDisconnect = false,
+    networkRetry = false,
+  }: {
+    networkDisconnect?: boolean;
+    networkRetry?: boolean;
+  } = {}) {
+    LoggerProxy.logger.info(
+      `ReconnectionManager:index#reconnect --> Reconnection start for meeting ${this.meeting.id}.`
+    );
     // First, validate that we can reconnect, if not, it will throw an error
     try {
       this.validate();
-    }
-    catch (error) {
-      LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Reconnection unable to begin.', error);
+    } catch (error) {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnect --> Reconnection unable to begin.',
+        error
+      );
       throw error;
     }
 
     if (!networkRetry) {
       // Only log START metrics on the initial reconnect
-      LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Sending reconnect start metric.');
-      Metrics.postEvent({
-        event: eventType.MEDIA_RECONNECTING,
-        meeting: this.meeting
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
+      );
+
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: this.meeting.id,
+        },
       });
     }
 
     return this.executeReconnection({networkDisconnect})
       .then(() => {
         LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Reconnection successful.');
-        LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Sending reconnect success metric.');
-        Metrics.postEvent({
-          event: eventType.MEDIA_RECOVERED,
-          meeting: this.meeting,
-          data: {recoveredBy: reconnection.RECOVERED_BY_NEW}
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#reconnect --> Sending reconnect success metric.'
+        );
+
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.recovered',
+          payload: {
+            recoveredBy: 'new',
+          },
+          options: {
+            meetingId: this.meeting.id,
+          },
         });
       })
       .catch((reconnectError) => {
         if (reconnectError instanceof NeedsRetryError) {
-          LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.');
+          LoggerProxy.logger.info(
+            'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
+          );
           // Reset our reconnect status since we are looping back to the beginning
           this.status = RECONNECTION.STATE.DEFAULT_STATUS;
 
@@ -291,26 +368,32 @@ export default class ReconnectionManager {
         }
 
         // Reconnect has failed
-        LoggerProxy.logger.error('ReconnectionManager:index#reconnect --> Reconnection failed.', reconnectError.message);
-        LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Sending reconnect abort metric.');
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#reconnect --> Reconnection failed.',
+          reconnectError.message
+        );
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
+        );
 
-        const reconnectMetric = {
-          event: eventType.CALL_ABORTED,
-          meeting: this.meeting,
-          data: {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.aborted',
+          payload: {
             errors: [
               {
-                category: errorObjects.category.expected,
+                category: 'expected',
                 errorCode: 2008,
                 fatal: true,
-                name: errorObjects.name.mediaEngine,
-                shownToUser: false
-              }
-            ]
-          }
-        };
-
-        Metrics.postEvent(reconnectMetric);
+                name: 'media-engine',
+                shownToUser: false,
+              },
+            ],
+          },
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
         if (reconnectError instanceof NeedsRejoinError) {
           // send call aborded event with catogery as expected as we are trying to rejoin
 
@@ -319,7 +402,6 @@ export default class ReconnectionManager {
           }
         }
 
-
         throw reconnectError;
       });
   }
@@ -332,43 +414,63 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  async executeReconnection({networkDisconnect = false}) {
+  private async executeReconnection({networkDisconnect = false}: {networkDisconnect?: boolean}) {
     this.status = RECONNECTION.STATE.IN_PROGRESS;
 
-    LoggerProxy.logger.info('ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.');
+    LoggerProxy.logger.info(
+      'ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.'
+    );
+
+    const wasSharing = this.meeting.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE;
+
+    if (wasSharing) {
+      await this.stopLocalShareStream(SHARE_STOPPED_REASON.MEDIA_RECONNECTION);
+    }
 
     if (networkDisconnect) {
       try {
         await this.reconnectMercuryWebSocket();
-        LoggerProxy.logger.error('ReconnectionManager:index#executeReconnection --> Websocket reconnected.', this.webex.internal.device.url);
-      }
-      catch (error) {
-        LoggerProxy.logger.error('ReconnectionManager:index#executeReconnection --> Unable to reconnect to websocket, giving up.');
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#executeReconnection --> Websocket reconnected.',
+          this.webex.internal.device.url
+        );
+      } catch (error) {
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#executeReconnection --> Unable to reconnect to websocket, giving up.'
+        );
         this.status = RECONNECTION.STATE.FAILURE;
-        throw (error);
+        throw error;
       }
     }
 
-    const wasSharing = this.meeting.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE;
-
-    try {
-      LoggerProxy.logger.info('ReconnectionManager:index#executeReconnection --> Updating meeting data from server.');
-      await this.webex.meetings.syncMeetings();
-    }
-    catch (syncError) {
-      LoggerProxy.logger.info('ReconnectionManager:index#executeReconnection --> Unable to sync meetings, reconnecting.', syncError);
-      throw (new NeedsRetryError(syncError));
+    if (!this.webex.credentials.isUnverifiedGuest) {
+      try {
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#executeReconnection --> Updating meeting data from server.'
+        );
+        await this.webex.meetings.syncMeetings();
+      } catch (syncError) {
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#executeReconnection --> Unable to sync meetings, reconnecting.',
+          syncError
+        );
+        throw new NeedsRetryError(syncError);
+      }
     }
 
     // TODO: try to improve this logic as the reconnection manager saves the instance of deleted meeting object
     // So that on rejoin it known what parametrs it was using
     if (!this.meeting || !this.webex.meetings.getMeetingByType(_ID_, this.meeting.id)) {
-      LoggerProxy.logger.info('ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely ');
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely.'
+      );
 
-      throw new Error('Unable to rejoin a meeting already ended or inactive .');
+      throw new Error('Unable to rejoin a meeting already ended or inactive.');
     }
 
-    LoggerProxy.logger.info(`ReconnectionManager:index#executeReconnection --> Current state of meeting is ${this.meeting.state}`);
+    LoggerProxy.logger.info(
+      `ReconnectionManager:index#executeReconnection --> Current state of meeting is ${this.meeting.state}`
+    );
 
     // If the meeting state was left, no longer reconnect media
     if (this.meeting.state === _LEFT_) {
@@ -376,22 +478,25 @@ export default class ReconnectionManager {
         throw new Error('Unable to rejoin a call in LEFT state.');
       }
 
-      throw (new NeedsRejoinError({wasSharing}));
+      throw new NeedsRejoinError({wasSharing});
     }
 
     try {
       const media = await this.reconnectMedia();
 
-      LoggerProxy.logger.log('ReconnectionManager:index#executeReconnection --> Media reestablished');
+      LoggerProxy.logger.log(
+        'ReconnectionManager:index#executeReconnection --> Media reestablished'
+      );
       this.status = RECONNECTION.STATE.COMPLETE;
 
       return media;
-    }
-    catch (error) {
-      LoggerProxy.logger.error('ReconnectionManager:index#executeReconnection --> Media reestablishment failed');
+    } catch (error) {
+      LoggerProxy.logger.error(
+        'ReconnectionManager:index#executeReconnection --> Media reestablishment failed'
+      );
       this.status = RECONNECTION.STATE.FAILURE;
 
-      throw (error);
+      throw error;
     }
   }
 
@@ -404,48 +509,34 @@ export default class ReconnectionManager {
    */
   async rejoinMeeting(wasSharing = false) {
     try {
-      LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> attemping meeting rejoin');
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#rejoinMeeting --> attemping meeting rejoin'
+      );
 
       await this.meeting.join({rejoin: true});
       LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> meeting rejoined');
 
       if (wasSharing) {
-        // Stop the share streams if user tried to rejoin
-        Media.stopTracks(this.meeting.mediaProperties.shareTrack);
-        this.meeting.isSharing = false;
-        if (this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
-          this.meeting.shareStatus = SHARE_STATUS.NO_SHARE;
-        }
-        this.meeting.mediaProperties.mediaDirection.sendShare = false;
-        Trigger.trigger(
-          this.meeting,
-          {
-            file: 'reconnection-manager/index',
-            function: 'rejoinMeeting'
-          },
-          EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-          {
-            reason: SHARE_STOPPED_REASON.MEETING_REJOIN
-          }
-        );
+        await this.stopLocalShareStream(SHARE_STOPPED_REASON.MEETING_REJOIN);
       }
-    }
-    catch (joinError) {
+    } catch (joinError) {
       this.rejoinAttempts += 1;
       if (this.rejoinAttempts <= this.maxRejoinAttempts) {
-        LoggerProxy.logger.info(`ReconnectionManager:index#rejoinMeeting --> Unable to rejoin meeting, attempt #${this.rejoinAttempts}, retrying.`, joinError);
+        LoggerProxy.logger.info(
+          `ReconnectionManager:index#rejoinMeeting --> Unable to rejoin meeting, attempt #${this.rejoinAttempts}, retrying.`,
+          joinError
+        );
         this.rejoinMeeting();
-      }
-      else {
-        LoggerProxy.logger.error('ReconnectionManager:index#rejoinMeeting --> Unable to rejoin meeting after max attempts.', joinError);
-        Metrics.sendBehavioralMetric(
-          BEHAVIORAL_METRICS.MEETING_MAX_REJOIN_FAILURE,
-          {
-            locus_id: this.meeting.locusUrl.split('/').pop(),
-            reason: joinError.message,
-            stack: joinError.stack
-          }
+      } else {
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#rejoinMeeting --> Unable to rejoin meeting after max attempts.',
+          joinError
         );
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_MAX_REJOIN_FAILURE, {
+          locus_id: this.meeting.locusUrl.split('/').pop(),
+          reason: joinError.message,
+          stack: joinError.stack,
+        });
         this.status = RECONNECTION.STATE.FAILURE;
         throw joinError;
       }
@@ -453,9 +544,11 @@ export default class ReconnectionManager {
 
     try {
       await this.reconnectMedia();
-    }
-    catch (mediaError) {
-      LoggerProxy.logger.error('ReconnectionManager:index#rejoinMeeting --> Unable to reestablish media after rejoining.', mediaError);
+    } catch (mediaError) {
+      LoggerProxy.logger.error(
+        'ReconnectionManager:index#rejoinMeeting --> Unable to reestablish media after rejoining.',
+        mediaError
+      );
       throw mediaError;
     }
   }
@@ -466,21 +559,34 @@ export default class ReconnectionManager {
    * @memberof ReconnectionManager
    */
   async reconnectMedia() {
-    LoggerProxy.logger.log('ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media');
+    LoggerProxy.logger.log(
+      'ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media'
+    );
 
-    // we are not simply calling this.meeting.mediaProperties.webrtcMediaConnection.reconnect(),
-    // but instead manually closing and creating new media connection, because we need to do the TURN discovery again
+    // do the TURN server discovery again and ignore reachability results since the TURN server might change
+    const turnServerResult = await this.meeting.roap.doTurnDiscovery(this.meeting, true, true);
 
-    await this.meeting.closePeerConnections();
-    this.meeting.mediaProperties.unsetPeerConnection();
+    const iceServers = [];
 
-    const turnServerInfo = await this.meeting.roap.doTurnDiscovery(this.meeting, true);
-
-    const mc = this.meeting.createMediaConnection(turnServerInfo);
+    if (turnServerResult.turnServerInfo) {
+      iceServers.push({
+        urls: turnServerResult.turnServerInfo.url,
+        username: turnServerResult.turnServerInfo.username || '',
+        credential: turnServerResult.turnServerInfo.password || '',
+      });
+    }
 
-    this.meeting.statsAnalyzer.updateMediaConnection(mc);
+    await this.meeting.mediaProperties.webrtcMediaConnection.reconnect(iceServers);
 
-    return mc.initiateOffer();
+    // resend media requests
+    if (this.meeting.isMultistream) {
+      Object.values(this.meeting.mediaRequestManagers).forEach(
+        (mediaRequestManager: MediaRequestManager) => {
+          mediaRequestManager.clearPreviousRequests();
+          mediaRequestManager.commit();
+        }
+      );
+    }
   }
 
   /**
@@ -489,31 +595,45 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  async reconnectMercuryWebSocket() {
-    LoggerProxy.logger.info('ReconnectionManager:index#reconnectMercuryWebSocket --> Reconnecting websocket.');
+  private async reconnectMercuryWebSocket() {
+    LoggerProxy.logger.info(
+      'ReconnectionManager:index#reconnectMercuryWebSocket --> Reconnecting websocket.'
+    );
     // First, attempt to disconnect if we think we are already connected.
     if (this.webex.internal.mercury.connected) {
-      LoggerProxy.logger.info('ReconnectionManager:index#reconnectMercuryWebSocket --> Disconnecting existing websocket.');
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnectMercuryWebSocket --> Disconnecting existing websocket.'
+      );
       try {
         await this.webex.internal.mercury.disconnect();
-        LoggerProxy.logger.info('ReconnectionManager:index#reconnectMercuryWebSocket --> Websocket disconnected successfully.');
-      }
-      catch (disconnectError) {
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#reconnectMercuryWebSocket --> Websocket disconnected successfully.'
+        );
+      } catch (disconnectError) {
         // If we can't disconnect, the sdk is in such a bad state that reconnecting is not going to happen.
-        LoggerProxy.logger.error('ReconnectionManager:index#reconnectMercuryWebSocket --> Unable to disconnect from websocket, giving up.', disconnectError);
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#reconnectMercuryWebSocket --> Unable to disconnect from websocket, giving up.',
+          disconnectError
+        );
         throw disconnectError;
       }
     }
 
     try {
-      LoggerProxy.logger.info('ReconnectionManager:index#reconnectMercuryWebSocket --> Connecting websocket.');
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnectMercuryWebSocket --> Connecting websocket.'
+      );
       await this.webex.internal.mercury.connect();
-      LoggerProxy.logger.info('ReconnectionManager:index#reconnectMercuryWebSocket --> Websocket connected successfully.');
-    }
-    catch (connectError) {
-      LoggerProxy.logger.error('ReconnectionManager:index#reconnectMercuryWebSocket --> Unable to connect to websocket, giving up.', connectError);
-
-      throw (connectError);
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnectMercuryWebSocket --> Websocket connected successfully.'
+      );
+    } catch (connectError) {
+      LoggerProxy.logger.error(
+        'ReconnectionManager:index#reconnectMercuryWebSocket --> Unable to connect to websocket, giving up.',
+        connectError
+      );
+
+      throw connectError;
     }
   }
 }

package/src/recording-controller/enums.ts

@@ -0,0 +1,8 @@
+enum RecordingAction {
+  Start = 'Start',
+  Stop = 'Stop',
+  Pause = 'Pause',
+  Resume = 'Resume',
+}
+
+export default RecordingAction;