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

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;

package/src/statsAnalyzer/global.js

@@ -1,131 +0,0 @@
-const STATS_DEFAULT = {
-  encryption: 'sha-256',
-  audio: {
-    send: {
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      bytesSent: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: []
-    },
-    recv: {
-      availableBandwidth: 0,
-      bytesReceived: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: []
-    }
-  },
-  video: {
-    send: {
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: []
-    },
-    recv: {
-      availableBandwidth: 0,
-      totalPacketsLost: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: []
-
-    },
-    latency: 0,
-    packetsLost: 0
-  },
-  share: {
-    send: {
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      totalPacketsLost: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: []
-    },
-    recv: {
-      availableBandwidth: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: []
-    },
-
-    latency: 0,
-    packetsLost: 0
-  },
-  bandwidth: {
-    systemBandwidth: 0,
-    sentPerSecond: 0,
-    encodedPerSecond: 0,
-    helper: {
-      audioBytesSent: 0,
-      videoBytestSent: 0
-    },
-    speed: 0
-  },
-  results: {},
-  connectionType: {
-    systemNetworkType: 'unknown',
-    systemIpAddress: '0.0.0.0',
-    local: {
-      candidateType: [],
-      transport: [],
-      ipAddress: [],
-      networkType: []
-    },
-    remote: {
-      candidateType: [],
-      transport: [],
-      ipAddress: [],
-      networkType: []
-    }
-  },
-  resolutions: {
-    audio: {
-      send: {
-        width: 0,
-        height: 0
-      },
-      recv: {
-        width: 0,
-        height: 0
-      }
-    },
-    video: {
-      send: {
-        width: 0,
-        height: 0
-      },
-      recv: {
-        width: 0,
-        height: 0
-      }
-    },
-    share: {
-      send: {
-        width: 0,
-        height: 0
-      },
-      recv: {
-        width: 0,
-        height: 0
-      }
-    }
-  },
-  internal: {
-    audio: {
-      send: {},
-      recv: {}
-    },
-    video: {
-      send: {},
-      recv: {}
-    },
-    share: {
-      send: {},
-      recv: {}
-    },
-    remote: {
-
-    },
-    candidates: {}
-  }
-};
-
-export default STATS_DEFAULT;