rb-sdk/lib/ToCRBClient.js

rb client sdk

"use strict";

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

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 _RBClient2 = require("./RBClient");

var _RBClient3 = _interopRequireDefault(_RBClient2);

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

var _RBEvent2 = _interopRequireDefault(_RBEvent);

var _SignalType = require("./SignalType");

var _SignalType2 = _interopRequireDefault(_SignalType);

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

var _RBDebugger2 = _interopRequireDefault(_RBDebugger);

var _store = require("store");

var _store2 = _interopRequireDefault(_store);

var _Api = require("./Api");

var _Api2 = _interopRequireDefault(_Api);

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"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var ToCRBClient = function (_RBClient) {
    _inherits(ToCRBClient, _RBClient);

    function ToCRBClient(configuration) {
        _classCallCheck(this, ToCRBClient);

        var _this2 = _possibleConstructorReturn(this, (ToCRBClient.__proto__ || Object.getPrototypeOf(ToCRBClient)).call(this, configuration));

        _this2.api = new _Api2.default(configuration);
        _this2.seat = null;
        _this2.isOffer = false;
        _this2._init();
        _this2._initScreenEventListener();
        return _this2;
    }

    _createClass(ToCRBClient, [{
        key: "_init",
        value: function _init() {
            var _this = this;

            _EventDispatcher2.default.addListener(_RBEvent2.default.SCHDULE_SUCCESS, function (event) {
                var data = event.data;
                _RBDebugger2.default.info('Event SCHDULE_SUCCESS will set session', data);
                var SESSION_ID = data.SESSION_ID,
                    SEAT_DEVICE_ID = data.SEAT_DEVICE_ID,
                    SEAT_ID = data.SEAT_ID,
                    STAFF_ID = data.STAFF_ID,
                    PROVINCE_CODE = data.PROVINCE_CODE;

                _this.session = _this.newSession(SESSION_ID);

                _this.setToDevice(SEAT_DEVICE_ID || null);
                _this.seat = { SEAT_ID: SEAT_ID, STAFF_ID: STAFF_ID, PROVINCE_CODE: PROVINCE_CODE };
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.SESSION_INIT, data));
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.SESSION_INIT, function (event) {
                _RBDebugger2.default.info('Event SESSION_INIT,add ext props to session', event);
                var data = event.data;
                var CREATE_TIME = data.CREATE_TIME;

                _this.addSession('createTime', CREATE_TIME);
                _this.addSession('extProps', _this.configuration.getExtProps());
                _this.addSession('fromDeviceMeta', _this.configuration.getDeviceMeta());
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.SCHDULE_FAILED, function (event) {
                _this.closeWs();
            });

            _EventDispatcher2.default.addListener(_SignalType2.default.SIGNAL_ANSWER, function (event) {
                _RBDebugger2.default.info('Recived remote answer signal...', event);
                var payload = event.data.payload;

                if (!payload.answer) {
                    _RBDebugger2.default.info('Remote reject answer ', event.data);

                    _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _SignalType2.default.SIGNAL_REJECT, event));
                    return;
                }

                _this.webRTC.createOffer();
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.WEBRTC_LOCAL_OFFER_CREATED, function (event) {
                _RBDebugger2.default.info('Local offer created and send to remote.', event);
                var offer = event.data;
                _this.sendSignal(_SignalType2.default.SIGNAL_OFFER, { offer: offer });
            });

            _EventDispatcher2.default.addListener(_SignalType2.default.SIGNAL_OFFER_ANSWER, function (event) {
                _RBDebugger2.default.info('Recived remote offer answer signal.', event);
                var payload = event.data.payload;

                _this.webRTC.receiveAnswer(payload.answer);
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.WEBRTC_ON_LOCALE_ICECANDIDATE, function (event) {
                _RBDebugger2.default.info('Local icecandidate created and sent to remote.', event);
                var e = event.data;
                _this.sendSignal(_SignalType2.default.SIGNAL_ICECANDIDATE, { candidate: e.candidate });
            });

            _EventDispatcher2.default.addListener(_SignalType2.default.SIGNAL_ICECANDIDATE, function (event) {
                _RBDebugger2.default.info('Recived remote icecandidate signal.', event);
                var payload = event.data.payload;

                _this.webRTC.addIceCandidate(payload.candidate);
            });

            _EventDispatcher2.default.addListener(_SignalType2.default.SIGNAL_HUNG_UP, function (event) {
                try {
                    _RBDebugger2.default.info('Recived remote hungup signal and the client release resource.', event);
                    _this.restSession();
                    _this.closeWebRTC();
                } catch (e) {
                    _RBDebugger2.default.error('The client release resource failed.', e);
                }

                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.ACTION_HUNG_UP, event.data));
            });
        }
    }, {
        key: "_initScreenEventListener",
        value: function _initScreenEventListener() {
            var _this = this;

            _EventDispatcher2.default.addListener(_SignalType2.default.SIGNAL_SCREEN_OFFER, function (event) {
                _RBDebugger2.default.info("Accept remote screen offer,so we will create conn and create answer:", event);
                var payload = event.data.payload;

                var offer = payload.offer;

                _this.screenRTC.connect();

                _this.screenRTC.createAnswer(offer);
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.ON_SCREEN_ANSWER_CREATED, function (event) {
                _RBDebugger2.default.info("Offer answer created and send that to remote:", event);
                var answer = event.data;
                _this.sendSignal(_SignalType2.default.SIGNAL_SCREEN_OFFER_ANSWER, { answer: answer });
            });

            _EventDispatcher2.default.addListener(_RBEvent2.default.ON_SCREEN_ICECANDIDATE, function (event) {
                _RBDebugger2.default.info("Local icecandidate create and send that to remote:", event);
                var e = event.data;
                _this.sendSignal(_SignalType2.default.SIGNAL_SCREEN_ICECANDIDATE, { candidate: e.candidate });
            });

            _EventDispatcher2.default.addListener(_SignalType2.default.SIGNAL_SCREEN_ICECANDIDATE, function (event) {
                _RBDebugger2.default.info('Recived remote candidate signal:', event);
                var payload = event.data.payload;

                _this.webRTC.addIceCandidate(payload.candidate);
            });
        }
    }, {
        key: "getDeviceType",
        value: function getDeviceType() {
            return 'rbc';
        }
    }, {
        key: "reCall",
        value: async function reCall() {
            var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var _options = arguments[1];
            var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

            var _this = this;
            var sessionId = _store2.default.get("rb-ssid") || null;
            var req = {
                extProps: this.configuration.getExtProps(),
                USER_ID: user.userId,
                SESSION_ID: sessionId,
                DEVICE: {
                    DEVICE_ID: this.fromDevice,
                    BROWSER_AGENT: JSON.stringify(this.browser),
                    IMEI: ''
                }
            };
            req = Object.assign(req, params);

            var _ref = await this.api.schedule(req),
                _ref2 = _slicedToArray(_ref, 2),
                err = _ref2[0],
                resp = _ref2[1];

            if (err || !resp || _Api2.default.NOMARL_RSPCODE != resp.respCode) {
                _RBDebugger2.default.error('Schedule failed,may be network error or no free seat resource', err || resp);
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(this, _RBEvent2.default.SCHDULE_FAILED, err || resp));
                return;
            }

            _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.SCHDULE_SUCCESS, resp.data));

            this.openLocalMedia(_options || null);

            var callTimer = setInterval(function () {
                if (!_this.webRTC.getLocalStream()) {
                    return;
                }

                clearInterval(callTimer);

                _this.sendSignal(_SignalType2.default.SIGNAL_REQUEST, _this.session);

                _this.webRTC.connect();
            }, 500);
            return resp;
        }
    }, {
        key: "_getUser",
        value: function _getUser() {
            var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var _user = user,
                userId = _user.userId;

            if (userId) {
                user.userId = userId;
                _store2.default.set("rb-user", user);
                return user;
            }

            if (!userId) {
                user = _store2.default.get("rb-user");
                if (!user || !user['userId']) {
                    var _userId = _store2.default.get('_rbdid');
                    user = { userId: _userId };
                    _store2.default.set("rb-user", user);
                }
            }
            return user;
        }
    }, {
        key: "call",
        value: async function call() {
            var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var _options = arguments[1];
            var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

            _store2.default.set("rb-ssid", '');
            user = this._getUser(user);

            this.connect();

            var _this = this;
            var checkCount = 0;
            var connectChecker = setInterval(function () {
                checkCount++;
                if (checkCount > 3) {
                    clearInterval(connectChecker);
                    _this.closeWs();
                    _RBDebugger2.default.error("Check [" + checkCount + "] times and infer Network error.", null);
                    _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(_this, _RBEvent2.default.NETWORK_ERROR_CALL_FAILED, null));
                    return;
                }
                if (1 === _this.socketState) {
                    _this.reCall(user, _options, params);
                    clearInterval(connectChecker);
                }
            }, 1000);
        }
    }, {
        key: "cancleCall",
        value: async function cancleCall() {
            var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

            try {
                this.closeWebRTC();
            } catch (e) {
                _RBDebugger2.default.error('Error close webrtc:', e);
            }
            var SEAT_STATE = 'SC4';
            var SEAT_ID = this.seat.SEAT_ID;
            var SESSION_ID = this.session.SESSION_ID;

            var SEAT_DEVICE_ID = this.getToDevice();
            var req = { SESSION_ID: SESSION_ID, SEAT_ID: SEAT_ID, SEAT_STATE: SEAT_STATE, SEAT_DEVICE_ID: SEAT_DEVICE_ID };
            req = Object.assign(req, params);

            var _ref3 = await this.api.hungUp(req),
                _ref4 = _slicedToArray(_ref3, 2),
                error = _ref4[0],
                resp = _ref4[1];

            if (error || !resp || _Api2.default.NOMARL_RSPCODE != resp.respCode) {
                _RBDebugger2.default.error('Hung up failed:', error || resp);
                _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(this, _RBEvent2.default.ACTION_HUNG_UP_FAILED, error || resp));
                return [error, resp];
            }
            if (this.session) {
                this.sendSignal(_SignalType2.default.SIGNAL_HUNG_UP);
            }
            this.restSession();
            this.closeWs();

            _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(this, _RBEvent2.default.ACTION_HUNG_UP_SUCCESS, resp));
            return [error, resp];
        }
    }, {
        key: "joinQueue",
        value: async function joinQueue() {
            var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

            user = this._getUser(user);
            var req = {
                USER_ID: user.userId
            };
            req = Object.assign(req, params);

            var _ref5 = await this.api.joinQueue(req),
                _ref6 = _slicedToArray(_ref5, 2),
                error = _ref6[0],
                resp = _ref6[1];

            if (error || !resp || _Api2.default.NOMARL_RSPCODE != resp.respCode) {
                _RBDebugger2.default.error('Join queue failed:', error || resp);
                return [error, resp];
            }

            _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(this, _RBEvent2.default.GET_QUEUE_STATE, resp));

            return [null, resp];
        }
    }, {
        key: "exitQueue",
        value: async function exitQueue() {
            var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

            user = this._getUser(user);
            var req = {
                USER_ID: user.userId
            };
            req = Object.assign(req, params);

            var _ref7 = await this.api.exitQueue(req),
                _ref8 = _slicedToArray(_ref7, 2),
                error = _ref8[0],
                resp = _ref8[1];

            if (error || !resp || _Api2.default.NOMARL_RSPCODE != resp.respCode) {
                _RBDebugger2.default.error('Exit queue failed:', error || resp);
                return [error, resp];
            }

            return resp;
        }
    }, {
        key: "getQueueRemind",
        value: async function getQueueRemind() {
            var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

            var req = {};
            if (!params.total) {
                user = this._getUser(user);
                req = {
                    USER_ID: user.userId
                };
            }
            req = Object.assign(req, params);

            var _ref9 = await this.api.getQueueRemind(req),
                _ref10 = _slicedToArray(_ref9, 2),
                error = _ref10[0],
                resp = _ref10[1];

            if (error || !resp || _Api2.default.NOMARL_RSPCODE != resp.respCode) {
                _RBDebugger2.default.error('Get queue state failed:', error || resp);
                return [error, resp];
            }

            _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(this, _RBEvent2.default.GET_QUEUE_STATE, resp));

            return [null, resp];
        }
    }, {
        key: "frontDisconnect",
        value: async function frontDisconnect() {
            var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

            var req = {};
            if (null != this.seat && null != this.session) {
                var SEAT_ID = this.seat.SEAT_ID;
                var SESSION_ID = this.session.SESSION_ID;

                req.SEAT_ID = SEAT_ID;
                req.SESSION_ID = SESSION_ID;
            }
            req.SEAT_DEVICE_ID = this.getToDevice();
            req.USER_ID = this._getUser(user);
            req = Object.assign(req, params);

            var _ref11 = await this.api.frontDisconnect(req),
                _ref12 = _slicedToArray(_ref11, 2),
                error = _ref12[0],
                resp = _ref12[1];

            if (error || !resp || _Api2.default.NOMARL_RSPCODE != resp.respCode) {
                _RBDebugger2.default.error('front disconnect failed:', error || resp);
                return [error, resp];
            }

            _EventDispatcher2.default.dispatchEvent(new _RBEvent2.default(this, _RBEvent2.default.GET_QUEUE_STATE, resp));

            return [null, resp];
        }
    }]);

    return ToCRBClient;
}(_RBClient3.default);

exports.default = ToCRBClient;