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

pooliot client

import Logger from 'nightingale';
import { runPipeAsUser, runSyncAsUser, runSync } from '../utils/exec';
import { sendUpdate } from '../client';
import * as display from './display';
import * as screensaver from './screensaver';
import { device } from '../params';

const logger = new Logger('app:commands:screen');

type ScreenStateType = 'on' | 'off' | 'unavailable';

const getScreens = (): Array<string> =>
  runSyncAsUser('./screen.sh', ['screens'])
    .split('\n')
    .filter(Boolean);

let currentScreens: Array<string> = getScreens();

const getScreenState = (): ScreenStateType =>
  currentScreens.length === 0 ? 'unavailable' : runSyncAsUser('./screen.sh', ['state']);

let currentScreenState: ScreenStateType = getScreenState();

// CONFIG
let disableTouchscreenIfHDMIConnected;
let reverseTouchscreen;

logger.info('init', { currentScreens, currentScreenState });

const isTouchscreen = screen => screen.startsWith('DSI');
const isHDMIScreen = screen => screen.startsWith('HDMI');

const updateCurrentScreenState = (newState: ScreenStateType = getScreenState()) => {
  currentScreens = getScreens();

  if (currentScreenState !== newState) {
    currentScreenState = newState;
    sendUpdate({
      screenState: currentScreenState,
      screen: { state: currentScreenState, screens: currentScreens },
    });
  }
};

const reverseScreen = (screen: string) =>
  runSyncAsUser('./screen.sh', ['reverse-screen', screen, device.touchscreen]);

const turnScreen = (state: 'on' | 'off'): void => {
  runSyncAsUser('./screen.sh', [state]);
  updateCurrentScreenState(state);
};

export const getCurrentScreenState = (): ScreenStateType => currentScreenState;
export const getCurrentScreens = (): Array<string> => currentScreens;

export const on = (autoStartDisplay = true): void => {
  logger.info('turning screen on');

  // start display before turning on to avoid blank screen
  if (autoStartDisplay) display.start();

  runSync('./screen.sh', ['root-on']);
  turnScreen('on');
  screensaver.set();

  if (disableTouchscreenIfHDMIConnected || reverseTouchscreen) {
    const touchscreens = currentScreens.filter(isTouchscreen);

    if (
      disableTouchscreenIfHDMIConnected &&
      touchscreens.length &&
      currentScreens.length > 1 &&
      currentScreens.some(isHDMIScreen)
    ) {
      runSyncAsUser('./screen.sh', ['screens-off', ...touchscreens]);
    } else if (reverseTouchscreen) {
      touchscreens.forEach(reverseScreen);
    } else {
      runSyncAsUser('./screen.sh', ['screens-on', ...touchscreens]);
    }
  }
};

export const off = (): void => {
  logger.info('turning screen off');
  display.stop();
  turnScreen('off');
};

export const update = (config: Object, firstTime: ?boolean = false) => {
  if (!display.supports(config.display)) {
    logger.warn('display not supported', { display: config.display });
    if (config.display !== 'none') off(); // only off if display is not "disabled"
    return;
  }

  if (firstTime) {
    runSyncAsUser('./screen.sh', ['waitForX']);
  }

  updateCurrentScreenState();

  if (currentScreenState === 'on') {
    display.update(config, true);
    if (firstTime) {
      // eslint-disable-next-line prefer-destructuring
      disableTouchscreenIfHDMIConnected = config.disableTouchscreenIfHDMIConnected;
      // eslint-disable-next-line prefer-destructuring
      reverseTouchscreen = config.reverseTouchscreen;
      on(false);
    } else if (
      disableTouchscreenIfHDMIConnected !== config.disableTouchscreenIfHDMIConnected ||
      reverseTouchscreen !== config.reverseTouchscreen
    ) {
      // eslint-disable-next-line prefer-destructuring
      disableTouchscreenIfHDMIConnected = config.disableTouchscreenIfHDMIConnected;
      // eslint-disable-next-line prefer-destructuring
      reverseTouchscreen = config.reverseTouchscreen;
      on(false);
    }
    screensaver.update(config);
  } else {
    display.update(config, false);
    screensaver.update(config, false);
  }
};

export const screenshot = () => {
  if (currentScreenState !== 'on') {
    logger.debug('screenshot: screen is not on');
    return;
  }

  logger.info('getting screenshot');
  return runPipeAsUser('./screen.sh', ['screenshot', device.id]);
};