pooliot-client/lib-node8/client.js

'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 _argv = require('./argv');

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

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

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

var display = _interopRequireWildcard(_display);

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

var screen = _interopRequireWildcard(_screen);

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

var _networkInterface2 = _interopRequireDefault(_networkInterface);

var _detectBoard = require('./utils/detectBoard');

var _detectBoard2 = _interopRequireDefault(_detectBoard);

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

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

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 = _argv.serverHost && _argv.serverPort && (0, _socket2.default)(`${_argv.serverHost}:${_argv.serverPort}/raspberry-client`, {
  reconnectionDelay: 500,
  reconnectionDelayMax: 120000,
  timeout: 4000,
  transports: ['websocket']
});

// wait 5s before connecting, leave the time to start display
setTimeout(() => {
  logger.debug('Connecting', { serverHost: _argv.serverHost, serverPort: _argv.serverPort });
  if (socket) {
    socket.connect();
  }
}, 5000);

const board = (0, _detectBoard2.default)();
const rpiVersion = board === 'rpi' && board.info;

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) {
  socket.on('connect_error', err => logger.error('connect error', { serverHost: _argv.serverHost, serverPort: _argv.serverPort, errMessage: err.message }));
  socket.on('reconnect_error', err => logger.debug('reconnect error', { serverHost: _argv.serverHost, serverPort: _argv.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: _argv.token,
      userId: _argv.token, // deprecated
      screenState }, networkInterface, {
      hostname: (0, _os.hostname)(),
      rpiVersion,
      board,
      screen: {
        state: screenState,
        screens: screen.getCurrentScreens()
      },
      availableDisplays: display.availableDisplays
    }));
  });

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

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

  socket.on('screenshot', () => {
    logger.info('screenshot');
    const buffer = screen.screenshot();
    if (!buffer) {
      return;
    }

    logger.info('send screenshot');
    socket.emit('screenshot', { image: true, buffer }, () => {
      logger.info('screenshot callback');
    });
  });
}

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