pooliot-client/src/client.js

pooliot client

import Logger from 'nightingale';
import { hostname } from 'os';
import createSocketClient from 'socket.io-client';
import { serverHost, serverPort, token } from './argv';
import { getTime as getConfigTime } from './config';
import { onConfigUpdated } from './manager';
import * as display from './commands/display';
import * as screen from './commands/screen';
import findNetworkInterface from './utils/networkInterface';
import detectBoard from './utils/detectBoard';
import { selfUpdate } from './update';
import { version } from '../package.json';

const logger = new Logger('app:client');

const socket =
  serverHost &&
  serverPort &&
  createSocketClient(`${serverHost}:${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, serverPort });
  if (socket) {
    socket.connect();
  }
}, 5000);

const board = detectBoard();
const rpiVersion = board === 'rpi' && board.info;

const emit = (eventName: string, ...args: Array<any>) => {
  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, serverPort, errMessage: err.message }),
  );
  socket.on('reconnect_error', err =>
    logger.debug('reconnect error', { serverHost, serverPort, err }),
  );

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

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

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

    const networkInterface = findNetworkInterface();
    const screenState = screen.getCurrentScreenState();
    emit('hello', {
      configTime: getConfigTime(),
      version,
      token,
      userId: token, // deprecated
      screenState, // deprecated
      ...networkInterface,
      hostname: hostname(),
      rpiVersion,
      board,
      screen: {
        state: screenState,
        screens: screen.getCurrentScreens(),
      },
      availableDisplays: display.availableDisplays,
    });
  });

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

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

  socket.on('action', (action: string) => {
    logger.info('received action', { action });
    switch (action) {
      case 'self-upgrade':
      case 'self-update':
      case 'selfUpdate':
        return 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');
    });
  });
}

export const sendUpdate = (data: Object): void => {
  emit('update', data);
};

export function close(): Promise<any> | void {
  if (!socket || !socket.connected) {
    return;
  }

  return new Promise(resolve => {
    logger.info('Closing...');
    socket.once('disconnect', () => {
      logger.info('Closed');
      resolve();
    });
    socket.close();
  });
}