@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.11

package/src/roap/index.js

@@ -1,380 +0,0 @@
-import {StatelessWebexPlugin} from '@webex/webex-core';
-
-import {ROAP} from '../constants';
-import LoggerProxy from '../common/logs/logger-proxy';
-import MeetingUtil from '../meeting/util';
-
-import RoapHandler from './handler';
-import RoapRequest from './request';
-import RoapCollection from './collection';
-import TurnDiscovery from './turnDiscovery';
-
-/**
- * Roap options
- * @typedef {Object} RoapOptions
- * @property {String} sdp
- * @property {Meeting} meeting
- * @property {Number} roapSeq
- * @property {Boolean} reconnect
- */
-
-/**
-  * @typedef {Object} SeqOptions
-  * @property {String} correlationId
-  * @property {String} mediaId
-  * @property {Number} seq
-  */
-
-/**
- * @class Roap
- * @export
- * @private
- */
-export default class Roap extends StatelessWebexPlugin {
-  /**
-   *
-   * @param {Object} attrs
-   * @param {Object} options
-   */
-  constructor(attrs, options) {
-    super({}, options);
-    /**
-     * @instance
-     * @type {Object}
-     * @private
-     * @memberof Roap
-     */
-    this.attrs = attrs;
-    /**
-     * @instance
-     * @type {Object}
-     * @private
-     * @memberof Roap
-     */
-    this.options = options;
-    /**
-     * The Roap Process State Handler
-     * @instance
-     * @type {RoapHandler}
-     * @private
-     * @memberof Roap
-     */
-    this.roapHandler = new RoapHandler(this.attrs, this.options, this.sendRoapOK.bind(this), this.sendRoapAnswer.bind(this), this.roapFinished.bind(this));
-    /**
-     * The Roap Request Server Proxy Object
-     * @instance
-     * @type {RoapRequest}
-     * @private
-     * @memberof Roap
-     */
-    this.roapRequest = new RoapRequest({}, options);
-    /**
-     * The last roap offer sent to server and acked
-     * @instance
-     * @type {Object}
-     * @private
-     * @memberof Roap
-     */
-    this.lastRoapOffer = {};
-
-    this.turnDiscovery = new TurnDiscovery(this.roapRequest);
-  }
-
-  /**
-   * Starts listening to mercury events for Roap messages
-   * @param {object} data event object
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  roapEvent(data) {
-    const msg = data.message;
-    const {correlationId} = data;
-
-    LoggerProxy.logger.log(`Roap:index#roapEvent --> Received Roap Message [${JSON.stringify(msg, null, 2)}]`);
-
-    if (msg.messageType === ROAP.ROAP_TYPES.TURN_DISCOVERY_RESPONSE) {
-      // turn discovery is not part of normal roap protocol and so we are not handling it
-      // through the usual roap state machine
-      this.turnDiscovery.handleTurnDiscoveryResponse(msg);
-    }
-    else {
-      this.roapHandler.submit({
-        type: ROAP.RECEIVE_ROAP_MSG,
-        msg,
-        correlationId
-      });
-    }
-  }
-
-  /**
-   *
-   * @param {String} correlationId correlation id of a meeting
-   * @param {Number} seq ROAP sequence number
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  stop(correlationId, seq) {
-    this.roapHandler.submit({
-      type: ROAP.RECEIVE_CALL_LEAVE,
-      seq,
-      correlationId
-    });
-
-    return Promise.resolve();
-  }
-
-  /**
-   *
-   * @param {SeqOptions} options
-   * @returns {null}
-   * @private
-   * @memberof Roap
-   */
-  sendRoapOK(options) {
-    return Promise.resolve().then(() => {
-      const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
-      const roapMessage = {
-        messageType: ROAP.ROAP_TYPES.OK,
-        version: ROAP.ROAP_VERSION,
-        seq: options.seq
-      };
-
-      LoggerProxy.logger.log(`Roap:index#sendRoapOK --> ROAP OK sending with seq ${options.seq}`);
-
-      return this.roapRequest
-        .sendRoap({
-          roapMessage,
-          locusSelfUrl: meeting.selfUrl,
-          mediaId: options.mediaId,
-          correlationId: options.correlationId,
-          audioMuted: meeting.isAudioMuted(),
-          videoMuted: meeting.isVideoMuted(),
-          meetingId: meeting.id
-        })
-        .then(() => {
-          this.roapHandler.submit({
-            type: ROAP.SEND_ROAP_MSG,
-            msg: roapMessage,
-            correlationId: options.correlationId
-          });
-          LoggerProxy.logger.log(`Roap:index#sendRoapOK --> ROAP OK sent with seq ${options.seq}`);
-          meeting.setRoapSeq(options.seq);
-        });
-    });
-  }
-
-  // eslint-disable-next-line no-warning-comments
-  // TODO: try to merge sendRoapOk and roapAnswer
-  /**
-   * Sends a ROAP answer...
-   * @param {SeqOptions} options
-   * @param {Boolean} options.audioMuted
-   * @param {Boolean} options.videoMuted
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  sendRoapAnswer(options) {
-    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
-    const roapMessage = {
-      messageType: ROAP.ROAP_TYPES.ANSWER,
-      sdps: options.sdps,
-      version: ROAP.ROAP_VERSION,
-      seq: options.seq
-    };
-
-    this.roapHandler.submit({
-      type: ROAP.SEND_ROAP_MSG,
-      msg: roapMessage,
-      correlationId: options.correlationId
-    });
-
-    return this.roapRequest
-      .sendRoap({
-        roapMessage,
-        locusSelfUrl: meeting.selfUrl,
-        mediaId: options.mediaId,
-        correlationId: options.correlationId,
-        audioMuted: options.audioMuted,
-        videoMuted: options.videoMuted,
-        meetingId: meeting.id
-      })
-      .then(() => {
-        meeting.setRoapSeq(options.seq);
-
-        this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: roapMessage.seq,
-          correlationId: meeting.correlationId
-        });
-      });
-  }
-
-  /**
-   * Sends a ROAP error...
-   * @param {Object} session
-   * @param {Object} locus
-   * @param {String} errorType
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  sendRoapError(session, locus, errorType) {
-    const msg = {
-      messageType: ROAP.ROAP_TYPES.ERROR,
-      version: ROAP.ROAP_VERSION,
-      errorType,
-      seq: session.OFFER.seq
-    };
-
-    return this.roapRequest.sendRoap(msg, locus);
-  }
-
-  /**
-   * sends a roap media request
-   * @param {RoapOptions} options
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  sendRoapMediaRequest(options) {
-    const {meeting, reconnect} = options;
-    const roapMessage = {
-      messageType: ROAP.ROAP_TYPES.OFFER,
-      sdps: [options.sdp],
-      // sdps: [options.sdp],
-      version: ROAP.ROAP_VERSION,
-      seq: typeof options.roapSeq !== 'number' && Number.isNaN(parseFloat(options.roapSeq)) ? 0 : options.roapSeq + 1,
-      tieBreaker: 4294967294 // Math.floor(Math.random() * (2 ** 32) - 1) // TODO: Handle the roap  conflict scenario
-    };
-
-    this.roapHandler.submit({
-      type: ROAP.SEND_ROAP_MSG,
-      msg: roapMessage,
-      correlationId: meeting.correlationId
-    });
-
-    // When reconnecting, it's important that the first roap message being sent out has empty media id.
-    // Normally this is the roap offer, but when TURN discovery is enabled,
-    // then this is the TURN discovery request message
-    const sendEmptyMediaId = reconnect && !meeting.config.experimental.enableTurnDiscovery;
-
-    return this.roapRequest
-      .sendRoap({
-        roapMessage,
-        correlationId: meeting.correlationId,
-        locusSelfUrl: meeting.selfUrl,
-        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
-        meetingId: meeting.id
-      })
-      .then(({locus, mediaConnections}) => {
-        this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: roapMessage.seq,
-          correlationId: meeting.correlationId
-        });
-        meeting.setRoapSeq(roapMessage.seq);
-
-        if (mediaConnections) {
-          meeting.updateMediaConnections(mediaConnections);
-        }
-
-        // eslint-disable-next-line no-warning-comments
-        // TODO: we need to attach peerconenction to locus not sure if we need to pass everything here
-        return locus;
-        // eslint-disable-next-line no-warning-comments
-        // TODO: check where to update the sequence number
-      });
-  }
-
-  /**
-   * sends a roap media request
-   * @param {RoapOptions} options
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  sendRoapCallRequest = (options) => {
-    const {meeting} = options;
-    const roapMessage = {
-      messageType: ROAP.ROAP_TYPES.OFFER,
-      sdps: [options.sdp],
-      version: ROAP.ROAP_VERSION,
-      seq: typeof options.roapSeq !== 'number' && Number.isNaN(parseFloat(options.roapSeq)) ? 0 : options.roapSeq + 1,
-      tieBreaker: 4294967294 // Math.floor(Math.random() * (2 ** 32) - 1) // TODO: Handle the roap  conflict scenario
-    };
-
-    this.roapHandler.submit({
-      type: ROAP.SEND_ROAP_MSG,
-      msg: roapMessage,
-      correlationId: meeting.correlationId
-    });
-
-    const roapBody = {
-      localMedias: [
-        {
-          localSdp: JSON.stringify(this.roapRequest.attachRechabilityData({
-            roapMessage,
-            // eslint-disable-next-line no-warning-comments
-            // TODO: check whats the need for video and audiomute
-            audioMuted: !!meeting.isAudioMuted(),
-            videoMuted: !!meeting.isVideoMuted()
-          }))
-        // mediaId: meeting.mediaId
-        }
-      ]
-    };
-
-    return MeetingUtil.joinMeetingOptions(meeting, {roapMessage: roapBody})
-      .then((locus) => {
-        this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: roapMessage.seq,
-          correlationId: meeting.correlationId
-        });
-        meeting.setRoapSeq(roapMessage.seq);
-
-        // eslint-disable-next-line no-warning-comments
-        // TODO: we need to attach peerconenction to locus not sure if we need to pass everything here
-        return locus;
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check where to update the sequence number
-      });
-  };
-
-  /**
- * Called when the roap sequence is finished (completed successfully or failed)
- * @param {String} correlationId id of the meeting affected
- * @param {String} sequenceId the id of the finished sequence
- * @returns {undefined}
- * @private
- * @memberof Roap
- */
-  roapFinished(correlationId, sequenceId) {
-    RoapCollection.onSessionSequenceFinish(correlationId, sequenceId);
-    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', correlationId);
-
-    meeting.mediaNegotiatedEvent();
-    if (!RoapCollection.isBusy(correlationId)) {
-      meeting.processNextQueuedMediaUpdate();
-    }
-  }
-
-  /**
-   * Performs a TURN server discovery procedure, which involves exchanging
-   * some roap messages with the server. This exchange has to be done before
-   * any other roap messages are sent
-   *
-   * @param {Meeting} meeting
-   * @param {Boolean} isReconnecting should be set to true if this is a new
-   *                                 media connection just after a reconnection
-   * @returns {Promise}
-   */
-  doTurnDiscovery(meeting, isReconnecting) {
-    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting);
-  }
-}

package/src/roap/state.js

@@ -1,149 +0,0 @@
-import StateMachine from 'javascript-state-machine';
-
-import LoggerProxy from '../common/logs/logger-proxy';
-import {ROAP, _OFFER_, _ANSWER_, _REQUESTED_} from '../constants';
-
-const shouldStep = (roap, meeting) => {
-  const {messageType} = roap.msg;
-
-  if (meeting) {
-    if (messageType === _OFFER_ && roap.remote && meeting.shareStatus === _REQUESTED_) {
-      // The peer-connection is waiting for answer but got an offer Reset. Try to
-      // send the offer later after you accept the answer
-      return false;
-    }
-    // Assuming the mercury event has come first before the response for the event
-    // we have to wait for the response and trigger the ROAP request later on
-    if (!meeting.mediaProperties.peerConnection && messageType === _ANSWER_) {
-      return false;
-    }
-  }
-  LoggerProxy.logger.log('Roap:state#shouldStep --> RoapStateMachine: PeerConnectionState, ', meeting.mediaProperties.peerConnection.signalingState);
-  LoggerProxy.logger.log('Roap:state#shouldStep --> RoapStateMachine: success save proceeding with transition, ', roap.msg);
-
-  return true;
-};
-
-const handleTransition = (value, signal, meeting) => {
-  LoggerProxy.logger.log(`Roap:state#handleTransition --> current ${value} to ${signal}`);
-
-  switch (value) {
-    case ROAP.ROAP_STATE.INIT:
-      if (signal === ROAP.ROAP_SIGNAL.RX_OFFER) {
-        return ROAP.ROAP_STATE.WAIT_TX_ANSWER;
-      }
-      if (signal === ROAP.ROAP_SIGNAL.TX_OFFER) {
-        return ROAP.ROAP_STATE.WAIT_RX_ANSWER;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_RX_OFFER:
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_RX_ANSWER:
-      if (signal === ROAP.ROAP_SIGNAL.RX_ANSWER) {
-        // There is a race condition where the /call response comes after mercury event from the server
-        // As mercury sends roap event if it didnt get back a response. We can send the roap ok after that
-        if (meeting.mediaId) {
-          return ROAP.ROAP_STATE.WAIT_TX_OK;
-        }
-        LoggerProxy.logger.error('Roap:state#handleTransition --> Race Condition no mediaId, continuing.');
-
-        return value;
-      }
-
-      if (signal === ROAP.ROAP_SIGNAL.RX_OFFER) {
-        return ROAP.ROAP_STATE.GLARE;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_TX_OFFER:
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_TX_ANSWER:
-      if (signal === ROAP.ROAP_SIGNAL.TX_ANSWER) {
-        return ROAP.ROAP_STATE.WAIT_RX_OK;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_TX_OK:
-      if (signal === ROAP.ROAP_SIGNAL.TX_OK) {
-        return ROAP.ROAP_STATE.INIT;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_RX_OK:
-      if (signal === ROAP.ROAP_SIGNAL.RX_OK) {
-        return ROAP.ROAP_STATE.INIT;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.ERROR:
-      // eslint-disable-next-line no-warning-comments
-      // TODO: resolve error state. Add a signal constant and handle the cleanup
-      return ROAP.ROAP_STATE.INIT;
-
-    case ROAP.ROAP_STATE.GLARE:
-      return ROAP.ROAP_STATE.WAIT_RX_ANSWER;
-    default:
-      return value;
-  }
-};
-
-const RoapStateMachine = {
-  /**
-   * @param {Roap} roapRef
-   * initializes the state machine
-   * @returns {StateMachine} an instance of a state machine
-   */
-  createState() {
-    const RoapState = StateMachine.factory({
-      init: ROAP.ROAP_STATE.INIT,
-      transitions: [
-        {
-          name: ROAP.ROAP_TRANSITIONS.STEP,
-          from: '*',
-          /**
-           * Method to handle the transitions between states
-           * @param {String} signal
-           * @param {Meeting} meeting instance of a Meeting
-           * @param {Object} roap
-           * @returns {String} new state value
-           */
-          to(signal, meeting, roap) {
-            const value = this.state;
-
-            if (!shouldStep(roap, meeting)) {
-              return value;
-            }
-
-            return handleTransition(value, signal, meeting);
-          }
-        }
-      ],
-      methods: {
-        /**
-         * Event that fires after we've transitioned to a new state
-         * @param {Object} transition
-         * @returns {null}
-         */
-        onAfterStep(transition) {
-          LoggerProxy.logger.log(
-            `Roap:state#onAfterStep --> RoapStateMachine->onAfterStep#fired! State changed from '${transition.from}' to '${
-              transition.to
-            }' with transition '${transition.transition}''.`
-          );
-        }
-      }
-    });
-
-    return new RoapState();
-  }
-};
-
-export default RoapStateMachine;

package/src/roap/util.js

@@ -1,93 +0,0 @@
-
-import PeerConnectionManager from '../peer-connection-manager';
-import {
-  _ANSWER_,
-  _ERROR_,
-  _CONFLICT_,
-  ROAP,
-  SDP
-} from '../constants';
-import LoggerProxy from '../common/logs/logger-proxy';
-import ParameterError from '../common/errors/parameter';
-
-const RoapUtil = {};
-const ROAP_ANSWER = _ANSWER_.toLowerCase();
-
-RoapUtil.shouldHandleMedia = (meeting) => {
-  const offer =
-    meeting.mediaProperties.peerConnection &&
-    meeting.mediaProperties.peerConnection.signalingState === SDP.HAVE_LOCAL_OFFER;
-
-  if (offer) {
-    return false;
-  }
-
-  return true;
-};
-
-RoapUtil.handleError = (pc) =>
-  PeerConnectionManager.rollBackLocalDescription({peerConnection: pc})
-    .then(() => Promise.resolve(true))
-    .catch((err) => {
-      LoggerProxy.logger.error(`Roap:util#handleError --> ${err}`);
-
-      return Promise.reject(err);
-    });
-
-RoapUtil.findError = (messageType, errorType, type) =>
-  (type === ROAP.RECEIVE_ROAP_MSG || type === ROAP.SEND_ROAP_MSG) && messageType === _ERROR_ && errorType === _CONFLICT_;
-
-RoapUtil.ensureMeeting = (meeting, type) => {
-  if (type === ROAP.RECEIVE_ROAP_MSG || type === ROAP.SEND_ROAP_MSG || type === ROAP.SEND_ROAP_MSG_SUCCESS) {
-    if (!meeting) {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-RoapUtil.updatePeerConnection = (meeting, session) => PeerConnectionManager.updatePeerConnection({
-  offerSdp: session.OFFER.sdps,
-  peerConnection: meeting.mediaProperties.peerConnection
-},
-{
-  meetingId: meeting.id,
-  remoteQualityLevel: meeting.mediaProperties.remoteQualityLevel
-})
-  .then((res) => {
-    meeting.roap.lastRoapOffer = session.OFFER.sdps;
-
-    return res;
-  });
-
-
-RoapUtil.setRemoteDescription = (meeting, session) => {
-  LoggerProxy.logger.info(`Roap:util#setRemoteDescription --> Transmit WAIT_TX_OK, correlationId: ${meeting.correlationId}`);
-  if (!(meeting && (meeting.mediaProperties.peerConnection))) {
-    LoggerProxy.logger.error(`Roap:util#setRemoteDescription --> DANGER no media or screen peer connection, correlationId: ${meeting.correlationId}`);
-
-    return Promise.reject(new ParameterError('Must provide a media or screen peer connection'));
-  }
-
-  return PeerConnectionManager.setRemoteSessionDetails(
-    meeting.mediaProperties.peerConnection,
-    ROAP_ANSWER,
-    session.ANSWER.sdps[0],
-    meeting.id
-  ).then(() => {
-    LoggerProxy.logger.info(`Roap:util#setRemoteDescription --> Success for correlationId: ${meeting.correlationId}`);
-
-    return {
-      seq: session.ANSWER.seq,
-      mediaId: meeting.mediaId,
-      correlationId: meeting.correlationId
-    };
-  })
-    .catch((err) => {
-      LoggerProxy.logger.error(`Roap:util#setRemoteDescription --> ${err}`);
-      throw err;
-    });
-};
-
-export default RoapUtil;