pooliot-client/src/main-process/client.js

import Logger from 'nightingale/src';
import { hostname } from 'os';
import createSocketClient from 'socket.io-client';
import { serverHost, serverPort, token, device } from './params';
import { getTime as getConfigTime } from './config';
import { onConfigUpdated } from './manager';
import * as screen from './commands/screen';
import * as display from './commands/display';
import availableDisplays from './utils/availableDisplays';
import findNetworkInterface from './utils/networkInterface';
import { selfUpdate } from './update';
import pkg from '../../package.json';
import { runSync } from './utils/exec';

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

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

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

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

if (socket) {
  // wait 1s before connecting
  setTimeout(() => {
    logger.debug('Connecting', { serverHost, serverPort });
    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(),
        client: { name: pkg.name, version: pkg.version },
        token,
        screenState, // deprecated
        ...networkInterface,
        hostname: hostname(),
        device,
        screen: {
          state: screenState,
          screens: screen.getCurrentScreens(),
        },
        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();

        case 'reboot':
          sendUpdate({ rebooting: true });
          display.stop();
          return runSync('reboot');

        case 'poweroff':
          sendUpdate({ rebooting: true });
          display.stop();
          return runSync('poweroff');
      }

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

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