rb-sdk/lib/WebRTC.js

rb client sdk

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _RBEvent = require('./RBEvent');

var _RBEvent2 = _interopRequireDefault(_RBEvent);

var _RBDebugger = require('./RBDebugger');

var _RBDebugger2 = _interopRequireDefault(_RBDebugger);

var _EventDispatcher = require('./EventDispatcher');

var _EventDispatcher2 = _interopRequireDefault(_EventDispatcher);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var WebRTC = function () {
  function WebRTC(config) {
    _classCallCheck(this, WebRTC);

    this.remoteStream = null;
    this.localStream = null;
    this.PeerConnection = window.webkitRTCPeerConnection || window.mozRTCPeerConnection || window.RTCPeerConnection || undefined;
    this.RTCSessionDescription = window.webkitRTCSessionDescription || window.mozRTCSessionDescription || window.RTCSessionDescription || undefined;
    this.conn = null;
    this.candidates = [];
    this.config = config;
    this._init();
  }

  _createClass(WebRTC, [{
    key: 'getUserMedia',
    value: async function getUserMedia(constrains) {
      var _this = this;
      var success = function success(e) {
        _RBDebugger2.default.info("Local media opened.", e);
        _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.LOCAL_MEDIA_OPENED, e));
      };
      var error = function error(e) {
        _RBDebugger2.default.error("Local media open failed.", e);
        _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.LOCAL_MEDIA_OPEN_FAILED, e));
      };
      if (navigator.mediaDevices.getUserMedia) {
        navigator.mediaDevices.getUserMedia(constrains).then(success).catch(error);
      } else if (navigator.mozGetUserMedia) {
        navigator.mozGetUserMedia(constrains, success, error);
      } else if (navigator.webkitGetUserMedia) {
        navigator.webkitGetUserMedia(constrains).then(success).catch(error);
      } else if (navigator.getUserMedia) {
        navigator.getUserMedia(constrains, success, error);
      }
    }
  }, {
    key: 'getSupportedConstraints',
    value: function getSupportedConstraints() {
      return navigator.mediaDevices ? navigator.mediaDevices.getSupportedConstraints() : {};
    }
  }, {
    key: '_init',
    value: function _init() {
      var _this = this;
      _EventDispatcher2.default.addListener(_RBEvent2.default.LOCAL_MEDIA_OPENED, function (event) {
        _RBDebugger2.default.info('Set local stream:', event.data);
        _this.localStream = event.data;
        _this.addLocalMediaToConnection();
      });

      _EventDispatcher2.default.addListener(_RBEvent2.default.REMOTE_MEDIA_OPENED, function (event) {
        var trackEvent = event.data;
        _this.remoteStream = trackEvent.stream || trackEvent.streams[0];
        _RBDebugger2.default.info('Set remote stream:', _this.remoteStream);
      });
    }
  }, {
    key: 'closeMedia',
    value: function closeMedia(video, audio) {
      if (false === video) {
        var tracks = this.localStream.getVideoTracks();
        tracks.forEach(function (track) {
          try {
            track.stop();
          } catch (e) {
            _RBDebugger2.default.error('Close vedio track error:', { track: track, e: e });
          }
        });
      }
      if (false === audio) {
        var _tracks = this.localStream.getAudioTracks();
        _tracks.forEach(function (track) {
          try {
            track.stop();
          } catch (e) {
            _RBDebugger2.default.error('Close vedio track error:', { track: track, e: e });
          }
        });
      }
    }
  }, {
    key: 'close',
    value: function close() {
      if (!this.localStream) {
        return;
      }

      var tracks = this.localStream.getTracks() || [];
      tracks.forEach(function (track) {
        try {
          track.stop();
        } catch (e) {
          _RBDebugger2.default.error('Close track error:', { track: track, e: e });
        }
      });

      this.localStream = null;

      if (this.conn) {
        this.conn.ontrack = null;
        this.conn.onnicecandidate = null;
        this.conn.oniceconnectionstatechange = null;
        this.conn.onsignalingstatechange = null;
        this.conn.onicegatheringstatechange = null;
        this.conn.onnotificationneeded = null;
        try {
          this.conn.close();
        } catch (e) {}
        this.conn = null;
      }
    }
  }, {
    key: '_dispatchEvent',
    value: function _dispatchEvent(rbEvent) {
      _EventDispatcher2.default.dispatchEvent(rbEvent);
    }
  }, {
    key: 'openMedia',
    value: function openMedia(options) {
      this.getUserMedia(options);
    }
  }, {
    key: 'addLocalMediaToConnection',
    value: function addLocalMediaToConnection() {
      if (this.localStream && this.conn) {
        _RBDebugger2.default.info('Add local stream in p2p connection', this.localStream);
        if ('addTrack' in this.conn) {
          for (var i = 0; i < this.localStream.getTracks().length; i++) {
            this.conn.addTrack(this.localStream.getTracks()[i], this.localStream);
          }
        } else {
          this.conn.addStream(this.localStream);
        }
      }
    }
  }, {
    key: 'connect',
    value: function connect() {
      _RBDebugger2.default.info('New PeerConnection ready to remote.');

      var serverConfig = {
        "iceServers": [{ 'urls': 'stun:stun.schlund.de' }, { 'urls': 'turn:221.11.103.34', 'username': 'admin', 'credential': 'admin' }, { 'urls': 'turn:221.11.103.35', 'username': 'admin', 'credential': 'admin' }]
      };

      var conn = this.conn = new this.PeerConnection(serverConfig);
      var _this = this;

      this.addLocalMediaToConnection();

      conn.onicecandidate = function (event) {
        _RBDebugger2.default.info('WebRTC event[onicecandidate] occured.', event);
        if (event.candidate) {
          _RBDebugger2.default.info('Print event.candidate:', event.candidate);
          _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.WEBRTC_ON_LOCALE_ICECANDIDATE, event));
        }
      };

      var inboundStream = null;
      var _ontrack = function _ontrack(e) {
        _RBDebugger2.default.info('Remote ontrack was recived:', e);
        if (e.stream || e.streams && e.streams[0]) {
          _RBDebugger2.default.info('Remote stream was recived:', e);
          _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.REMOTE_MEDIA_OPENED, e));
        } else {
          if (!inboundStream) {
            inboundStream = new MediaStream();
          }
          inboundStream.addTrack(e.track);
        }
      };
      conn.ontrack = _ontrack;

      conn.oniceconnectionstatechange = function (event) {};

      conn.onicegatheringstatechange = function (event) {};

      conn.onsignalingstatechange = function (event) {};
      conn.onnegotiationneeded = function (event) {};
    }
  }, {
    key: 'addIceCandidate',
    value: function addIceCandidate(candidate) {
      var rtcCandidate = new RTCIceCandidate(candidate);
      this.conn.addIceCandidate(rtcCandidate, function (candidate) {}, function (e) {
        _RBDebugger2.default.error('Add addIceCandidate failed:', e);
      });
      _RBDebugger2.default.info('Begin add icecandidate to connection.', candidate);
    }
  }, {
    key: 'createOffer',
    value: function createOffer() {
      if (this.conn.signalingState != "stable") {
        _RBDebugger2.default.error("The connection isn't stable yet; so exit:", this.conn.signalingState);
        return;
      }
      _RBDebugger2.default.info('Begin create local offer.', null);
      var _this = this;
      this.conn.createOffer().then(function (offer) {
        _this.conn.setLocalDescription(offer);
        _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.WEBRTC_LOCAL_OFFER_CREATED, offer));
        _RBDebugger2.default.info('Complated create offer.', offer);
      }).catch(function (e) {
        _RBDebugger2.default.error('Failed create Local conn offer.', e);
        _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.WEBRTC_FAILED, e));
      });
    }
  }, {
    key: 'createAnswer',
    value: function createAnswer(_offer) {
      _RBDebugger2.default.info('Begin create answer with offer:', _offer);
      var _this = this;
      var rtcsDesc = new RTCSessionDescription(_offer);
      if (_this.conn.signalingState != "stable") {
        _this.conn.setLocalDescription({ type: "rollback" });
        _this.conn.setRemoteDescription(rtcsDesc, function () {}, function () {});
        _RBDebugger2.default.error('P2P conn state is not [stable] so exit.', _this.conn.signalingState);
        return;
      }

      this.conn.setRemoteDescription(rtcsDesc, function () {}, function () {});
      this.conn.createAnswer(function (answer) {
        _this.conn.setLocalDescription(answer);
        _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.WEBRTC_ANSWER_CREATED, answer));
        _RBDebugger2.default.info('Finish create answer:', answer);
      }, function (e) {
        _RBDebugger2.default.error('Failed to create answer.', e);
        _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.WEBRTC_FAILED, e));
      });
    }
  }, {
    key: 'receiveAnswer',
    value: function receiveAnswer(answer) {
      var rtcs = new RTCSessionDescription(answer);
      this.conn.setRemoteDescription(rtcs);
      _RBDebugger2.default.info('Recevied answer:', answer);
    }
  }, {
    key: 'getLocalStream',
    value: function getLocalStream() {
      return this.localStream;
    }
  }, {
    key: 'getRemoteStream',
    value: function getRemoteStream() {
      return this.remoteStream;
    }
  }, {
    key: 'applyConstraints',
    value: function applyConstraints(setting) {
      if (!setting || 'local' !== setting.stream && 'remote' !== setting.stream) {
        _RBDebugger2.default.error('The param setting is illegal:', setting);
        return;
      }
      var stream = 'remote' === setting.stream ? this.remoteStream : this.localStream;
      var tragetTrack = null;
      stream.getTracks().forEach(function (track) {
        if ('audio' === setting.media && 'audio' == track.kind) {
          tragetTrack = track;
        }
        if ('video' === setting.media && 'video' == track.kind) {
          tragetTrack = track;
        }
      });

      if (!tragetTrack) {
        _RBDebugger2.default.warn('No track found:', setting);
        return;
      }

      tragetTrack.applyConstraints(setting.constraints).catch(function (e) {
        _RBDebugger2.default.error('Apply tracke constraints error:', e);
      });
    }
  }, {
    key: 'enabledAudio',
    value: function enabledAudio(enabled) {
      if (!this.localStream) {
        return null;
      }
      var track = this.localStream.getAudioTracks()[0];
      if (true === enabled || false === enabled) {
        track.enabled = enabled;
      }
      return track.enabled;
    }
  }, {
    key: 'enabledVideo',
    value: function enabledVideo(enabled) {
      if (!this.localStream) {
        return;
      }
      var track = this.localStream.getVideoTracks()[0];
      if (true === enabled || false === enabled) {
        track.enabled = enabled;
      }
      return track.enabled;
    }
  }]);

  return WebRTC;
}();

exports.default = WebRTC;