rb-sdk/lib/RBClient.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 _WebRTC = require('./WebRTC');

var _WebRTC2 = _interopRequireDefault(_WebRTC);

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

var _EventDispatcher2 = _interopRequireDefault(_EventDispatcher);

var _store = require('store');

var _store2 = _interopRequireDefault(_store);

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

var _RBDebugger2 = _interopRequireDefault(_RBDebugger);

var _Configuration = require('./Configuration');

var _Configuration2 = _interopRequireDefault(_Configuration);

var _Detector = require('./Detector');

var _Detector2 = _interopRequireDefault(_Detector);

var _ScreenRTC = require('./ScreenRTC');

var _ScreenRTC2 = _interopRequireDefault(_ScreenRTC);

var _WebSocket = require('./WebSocket');

var _WebSocket2 = _interopRequireDefault(_WebSocket);

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 RBClient = function () {
    function RBClient(configuration) {
        _classCallCheck(this, RBClient);

        this.rbDebugger = _RBDebugger2.default;
        if (!(configuration instanceof _Configuration2.default)) {
            this.rbDebugger.error("The configuration is not instance of Configuration.", null);
            throw new Error("The configuration is not instance of Configuration.");
        }
        this.configuration = configuration;
        this.webRTC = new _WebRTC2.default(this.configuration, this);
        this.screenRTC = new _ScreenRTC2.default(this.configuration);

        this.browser = _Detector2.default.browser;

        this.setToDevice(null);
        this.session = null;
        this._initBind();
        this.closed = false;
        this.socketRetrys = 0;
        this.socketState = 0;

        var _this = this;

        _this.setFromDevice(_this.getDevice());
    }

    _createClass(RBClient, [{
        key: '_initBind',
        value: function _initBind() {
            var _this = this;

            _EventDispatcher2.default.addListener(_RBEvent2.default.CONN_OPENED, function (event) {
                this.sendSignal('__create', this.fromDevice);
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.MESSAGE_SINGAL, function (event) {
                var singal = event.data;
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, singal.eventName, singal));
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.MESSAGE_DIRECTIVE, function (event) {
                var singal = event.data;

                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, singal.eventName, singal.payload));
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.CONN_RECONNECTE, function (event) {
                _this.reConnect();
            });
        }
    }, {
        key: 'getDevice',
        value: function getDevice() {
            var deviceType = this.getDeviceType && this.getDeviceType() || 'rb';
            deviceType = deviceType + '_device';
            var device = _store2.default.get(deviceType);
            if (!device) {
                device = _store2.default.get('_rbdid');
            }
            if (!device) {
                throw new Error("Unable to get device id.");
            }
            _store2.default.set(deviceType, device);
            _store2.default.set("_rbbd", device);
            return device;
        }
    }, {
        key: 'newSession',
        value: function newSession(ID) {
            this.session = { SESSION_ID: ID };
            return this.session;
        }
    }, {
        key: 'addSession',
        value: function addSession(key, value) {
            if (!this.session) {
                return this.session;
            }
            this.session[key] = value;
        }
    }, {
        key: 'getSession',
        value: function getSession() {
            return this.session;
        }
    }, {
        key: 'restSession',
        value: function restSession() {
            this.session = null;
            this.setToDevice(null);
            return this;
        }
    }, {
        key: 'setFromDevice',
        value: function setFromDevice(device) {
            this.fromDevice = device;
        }
    }, {
        key: 'setToDevice',
        value: function setToDevice(device) {
            this.toDevice = device;
        }
    }, {
        key: 'getToDevice',
        value: function getToDevice() {
            return this.toDevice;
        }
    }, {
        key: 'connect',
        value: function connect() {
            var _this = this;
            try {
                this.ws = new _WebSocket2.default(this.configuration.getWs().url);
            } catch (e) {
                _this.socketState = -1;
                _RBDebugger2.default.error('Create ws channel error:', e);
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.CONN_CREATE_FAIL));
                return this;
            }

            this.ws.onopen = function (e) {
                _RBDebugger2.default.info('Singal channel opened:', e);
                if (-1 === _this.socketState) {
                    _RBDebugger2.default.info('WS connection recoverd :', e);
                    _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.CONN_RECOVERED));
                }
                _this.socketState = 1;
                _this.socketRetrys = 1;
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.CONN_OPENED));
            };

            this.ws.onmessage = function (event) {
                _this.socketRetrys = 1;
                _this.socketState = 1;
                var singalEvt = JSON.parse(event.data);
                _RBDebugger2.default.info('Singal channel recived message:', singalEvt);
                if ('_singal' == singalEvt.eventType) {
                    _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.MESSAGE_SINGAL, singalEvt));
                } else {
                    _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.MESSAGE_DIRECTIVE, singalEvt));
                }
            };

            this.ws.error = function (e) {
                _this.socketState = -1;
                _RBDebugger2.default.error('Singal channel error occured:', e);
            };
            this.ws.onclose = function (e) {
                _this.socketState = -1;
                _RBDebugger2.default.info('Singal Channel closed:', e);
                _this.ws.close();
            };

            if (!_this.wsMonitor) {
                this._startWsMonitor();
            }
            return this;
        }
    }, {
        key: 'reConnect',
        value: function reConnect() {
            var _this = this;
            if (_this.socketRetrys > 3 && -1 === _this.socketState) {
                var _event = { socketRetrys: _this.socketRetrys, socketState: _this.socketState };
                _RBDebugger2.default.error('Connection retry max time and close ws :', _event);
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.MAX_RETRY_CONN_FAILED, _event));
                return;
            }

            if (-1 === _this.socketState) {
                var state = _this.socketState;
                _this.socketRetrys++;
                _RBDebugger2.default.info('Trigger ws reconnection,current ws state:[' + state + ']:', state);
                _this.connect();
            }
        }
    }, {
        key: '_startWsMonitor',
        value: function _startWsMonitor() {
            var _this = this;
            _this.wsMonitor = window.setInterval(function () {
                _this.reConnect();
            }, 20000);

            _this.pingMonitor = window.setInterval(function () {
                if (1 === _this.socketState) {
                    _this._send("ping");
                }
            }, 60000);

            _RBDebugger2.default.info('Start ws connection monitor', null);
        }
    }, {
        key: 'sendServer',
        value: function sendServer(event, payload) {
            var evtObject = { eventName: event, eventType: '_singal', from: this.fromDevice };
            if (payload) {
                event.payload = payload;
            }
            _RBDebugger2.default.info('Send singal to server:', evtObject);
            event = JSON.stringify(evtObject);
            this._send(event);
            return this;
        }
    }, {
        key: '_send',
        value: function _send(event) {
            try {
                if (this.ws == null || 2 === this.ws.readyState || 3 === this.ws.readyState) {
                    throw new Error("websocket closed ");
                }
                this.ws.send(event);
            } catch (e) {
                _RBDebugger2.default.error('ws send message error:', e);
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(this, _RBEvent2.default.MESSAGE_SEND_ERROR, event));
            }
        }
    }, {
        key: 'sendSignal',
        value: function sendSignal(signal, payload) {
            var evtObject = { eventName: signal, eventType: '_singal', from: this.fromDevice, to: this.toDevice, payload: payload };
            _RBDebugger2.default.info('Send singal:', evtObject);
            event = JSON.stringify(evtObject);
            this._send(event);
            return this;
        }
    }, {
        key: 'send',
        value: function send(event, payload) {
            var evtObject = { eventName: event, eventType: '_directive', from: this.fromDevice, to: this.toDevice, payload: payload };
            _RBDebugger2.default.info('Send directive:', evtObject);
            event = JSON.stringify(evtObject);
            this._send(event);
            return this;
        }
    }, {
        key: 'openLocalMedia',
        value: function openLocalMedia(rtcOpts) {
            var mate = this.configuration.getDeviceMeta();
            var constraints = this.webRTC.getSupportedConstraints();
            var defaultConstraints = {
                video: { width: mate.width, height: mate.height }, audio: { echoCancellation: true }
            };
            if (constraints['facingMode']) {
                defaultConstraints.video['facingMode'] = { exact: "user" };
            }

            if (constraints['frameRate']) {
                defaultConstraints.video['frameRate'] = { min: 30, max: 60 };
            }

            if (constraints['noiseSuppression']) {
                defaultConstraints.audio['noiseSuppression'] = true;
            }

            rtcOpts = rtcOpts || defaultConstraints;
            this.webRTC.openMedia(rtcOpts);
        }
    }, {
        key: 'closeLocalMedia',
        value: function closeLocalMedia(rtcOpts) {
            if (!rtcOpts) {
                throw new Error("The parameter rtcOpts is illegal.");
            }
            var video = true,
                audio = true;

            if (false === rtcOpts.video) {
                video = false;
            }
            if (false === rtcOpts.audio) {
                audio = false;
            }
            this.webRTC.closeMedia(video, audio);
        }
    }, {
        key: 'switchCamera',
        value: function switchCamera(_call) {
            _call(this.webRTC.getLocalStream(), this.webRTC.getRemoteStream());
        }
    }, {
        key: 'closeWs',
        value: function closeWs() {
            this.closed = true;
            if (this.wsMonitor) {
                window.clearInterval(this.wsMonitor);
                this.wsMonitor = null;
            }
            if (this.pingMonitor) {
                window.clearInterval(this.pingMonitor);
                this.pingMonitor = null;
            }
            if (this.ws) {
                this.ws.close();
            }
            _RBDebugger2.default.info('Distory singal channel.', null);
        }
    }, {
        key: 'closeWebRTC',
        value: function closeWebRTC() {
            _RBDebugger2.default.info('Distory webrtc.', null);
            if (this.webRTC) {
                this.webRTC.close();
            }
        }
    }, {
        key: 'applyConstraints',
        value: function applyConstraints(setting) {
            this.webRTC.applyConstraints(setting);
        }
    }, {
        key: 'enabledVideo',
        value: function enabledVideo(enabled) {
            return this.webRTC.enabledVideo(enabled);
        }
    }, {
        key: 'enabledAudio',
        value: function enabledAudio(enabled) {
            return this.webRTC.enabledAudio(enabled);
        }
    }]);

    return RBClient;
}();

exports.default = RBClient;