pooliot-client/lib-node8/main-process/client.js

pooliot client

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sendUpdate = undefined;
exports.close = close;

var _nightingale = require('nightingale');

var _nightingale2 = _interopRequireDefault(_nightingale);

var _os = require('os');

var _socket = require('socket.io-client');

var _socket2 = _interopRequireDefault(_socket);

var _params = require('./params');

var _config = require('./config');

var _manager = require('./manager');

var _screen = require('./commands/screen');

var screen = _interopRequireWildcard(_screen);

var _display = require('./commands/display');

var display = _interopRequireWildcard(_display);

var _availableDisplays = require('./utils/availableDisplays');

var _availableDisplays2 = _interopRequireDefault(_availableDisplays);

var _networkInterface = require('./utils/networkInterface');

var _networkInterface2 = _interopRequireDefault(_networkInterface);

var _update = require('./update');

var _package = require('../../package.json');

var _exec = require('./utils/exec');

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

const logger = new _nightingale2.default('app:client');

const socket = _params.serverHost && _params.serverPort && (0, _socket2.default)(`${_params.serverHost}:${_params.serverPort}/raspberry-client`, {
  autoConnect: false,
  reconnection: true,
  reconnectionDelay: 500,
  reconnectionDelayMax: 120000, // 2 minutes
  reconnectionAttempts: Infinity,
  timeout: 4000,
  transports: ['websocket']
});

const emit = (eventName, ...args) => {
  if (!socket) {
    logger.warn('cannot emit', { eventName, args });
    return;
  }

  logger.debug('emit', { eventName, args });
  return socket.emit(eventName, ...args);
};

if (socket) {
  // wait 1s before connecting
  setTimeout(() => {
    logger.debug('Connecting', { serverHost: _params.serverHost, serverPort: _params.serverPort });
    socket.on('connect_error', err => logger.error('connect error', { serverHost: _params.serverHost, serverPort: _params.serverPort, errMessage: err.message }));
    socket.on('reconnect_error', err => logger.debug('reconnect error', { serverHost: _params.serverHost, serverPort: _params.serverPort, err }));

    socket.on('disconnect', () => logger.warn('disconnected'));

    socket.on('reconnect', () => logger.success('reconnected'));

    socket.on('connect', () => {
      logger.success('connected');

      const networkInterface = (0, _networkInterface2.default)();
      const screenState = screen.getCurrentScreenState();
      emit('hello', Object.assign({
        configTime: (0, _config.getTime)(),
        version: _package.version,
        token: _params.token,
        userId: _params.token, // deprecated
        screenState }, networkInterface, {
        hostname: (0, _os.hostname)(),
        board: _params.board,
        screen: {
          state: screenState,
          screens: screen.getCurrentScreens()
        },
        availableDisplays: _availableDisplays2.default
      }));
    });

    socket.on('updateConfig', _manager.onConfigUpdated);
    socket.on('changeConfig', _manager.onConfigUpdated);

    socket.on('selfUpdate', () => (0, _update.selfUpdate)());

    socket.on('action', action => {
      logger.info('received action', { action });
      switch (action) {
        case 'self-upgrade':
        case 'self-update':
        case 'selfUpdate':
          return (0, _update.selfUpdate)();

        case 'screen-off':
          return screen.off();
        case 'screen-on':
          return screen.on();

        case 'refresh':
          return display.refresh();

        case 'reboot':
          display.stop();
          return (0, _exec.runSync)('reboot');
      }

      logger.warn(`unknown action: ${action}`);
    });

    socket.on('poll-data', () => {
      logger.debug('poll data');
      const screenshotBuffer = screen.screenshot();
      if (!screenshotBuffer) {
        return;
      }

      logger.debug('send screenshot');
      socket.emit('update-data', { screenshotBuffer });
    });

    socket.connect();
  }, 1000);
}

const sendUpdate = exports.sendUpdate = data => {
  emit('update', data);
};

function close() {
  if (!socket || !socket.connected) {
    return;
  }

  return new Promise(resolve => {
    logger.info('Closing...');
    socket.once('disconnect', () => {
      logger.info('Closed');
      resolve();
    });
    socket.close();
  });
}
//# sourceMappingURL=client.js.map