895 lines
19 KiB
JavaScript
895 lines
19 KiB
JavaScript
/* jshint esversion: 6, asi: true, strict: true*/
|
|
/* global require, setTimeout, process, console*/
|
|
|
|
'use strict'
|
|
|
|
const electron = require('electron')
|
|
const { Menu, MenuItem, ipcMain, BrowserWindow, app } = electron
|
|
const fs = require('fs')
|
|
const os = require('os')
|
|
const { createLogger, format, transports } = require('winston')
|
|
const { combine, timestamp, label, printf, colorize, prettyPrint, simple } = format
|
|
const moment = require('moment')
|
|
const uuid = require('uuid')
|
|
const events = require('events')
|
|
const path = require('path')
|
|
|
|
const ee = new events.EventEmitter()
|
|
//const digital = require('./lib/digital')
|
|
//const capture = require('./lib/capture')(ee)
|
|
const settings = require('settings')
|
|
const system = require('system')
|
|
const Server = require('server')
|
|
const Intval = require('intval')
|
|
const delay = require('delay')
|
|
|
|
//Objects
|
|
const mcopy = {}
|
|
const log = {}
|
|
const proj = {}
|
|
const cam = {}
|
|
const light = {}
|
|
const dev = {}
|
|
|
|
let mainWindow
|
|
let mscript
|
|
let arduino
|
|
let intval
|
|
let projector
|
|
let camera
|
|
let server
|
|
let menu
|
|
|
|
let SYSTEM
|
|
let capture
|
|
let display
|
|
let ffmpeg
|
|
let ffprobe
|
|
|
|
mcopy.cfg = require('./data/cfg.json')
|
|
mcopy.settings = {}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
dev.init = function () {
|
|
dev.listen()
|
|
}
|
|
|
|
dev.listen = function () {
|
|
ipcMain.on('profile', (event, arg) => {
|
|
log.info(`Saving profile ${arg.profile}`, 'SETTINGS', false, false)
|
|
settings.update('profile', arg.profile)
|
|
settings.save()
|
|
})
|
|
}
|
|
|
|
dev.enumerate = async function () {
|
|
let devices
|
|
try{
|
|
devices = await arduino.enumerate()
|
|
} catch (err) {
|
|
log.info(err, 'SERIAL', false, true)
|
|
await delay(1000)
|
|
return dev.all([])
|
|
}
|
|
log.info(`Found ${devices.length} USB devices`, 'SERIAL', true, true)
|
|
devices = dev.favor(devices)
|
|
return await dev.all(devices)
|
|
}
|
|
|
|
dev.favor = function (devices) {
|
|
const past = mcopy.settings.devices.filter(device => {
|
|
if (device.arduino) {
|
|
return device
|
|
}
|
|
}).map(device => {
|
|
return device.arduino
|
|
})
|
|
if (past.length === 0) {
|
|
return devices
|
|
}
|
|
devices.sort((a, b) => {
|
|
if (past.indexOf(a) !== -1 && past.indexOf(b) === -1) {
|
|
return 1
|
|
} else if (past.indexOf(a) === -1 && past.indexOf(b) !== -1) {
|
|
return -1
|
|
}
|
|
return 0
|
|
})
|
|
return devices
|
|
}
|
|
|
|
dev.distinguish = async function (device) {
|
|
let connectSuccess
|
|
let verifySuccess
|
|
let type
|
|
|
|
try {
|
|
connectSuccess = await arduino.connect('connect', device, true)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return null
|
|
}
|
|
|
|
await delay(2000)
|
|
|
|
try {
|
|
verifySuccess = await arduino.verify()
|
|
} catch (err) {
|
|
console.error(err)
|
|
return null
|
|
}
|
|
|
|
log.info(`Verified ${device} as mcopy device`, 'SERIAL', true, true)
|
|
|
|
await delay(1000)
|
|
|
|
try {
|
|
type = await arduino.distinguish()
|
|
} catch (err) {
|
|
console.error(err)
|
|
return null
|
|
}
|
|
|
|
dev.remember('arduino', device, type)
|
|
log.info(`Determined ${device} to be ${type}`, 'SERIAL', true, true)
|
|
|
|
return type
|
|
}
|
|
|
|
dev.fakeProjector = async function () {
|
|
dev.connected.projector = '/dev/fake'
|
|
try {
|
|
await arduino.fakeConnect('projector')
|
|
} catch (err) {
|
|
console.error(err)
|
|
log.error(`Error connecting to fake PRONECTOR device`, 'SERIAL', true, true)
|
|
return false
|
|
}
|
|
log.info('Connected to fake PROJECTOR device', 'SERIAL', true, true)
|
|
return true
|
|
}
|
|
dev.fakeCamera = async function () {
|
|
dev.connected.camera = '/dev/fake'
|
|
try {
|
|
await arduino.fakeConnect('camera')
|
|
} catch (err) {
|
|
console.error(err)
|
|
log.error(`Error connecting to fake CAMERA device`, 'SERIAL', true, true)
|
|
return false
|
|
}
|
|
log.info('Connected to fake CAMERA device', 'SERIAL', true, true)
|
|
return true
|
|
}
|
|
dev.fakeLight = async function () {
|
|
dev.connected.light = '/dev/fake'
|
|
try {
|
|
await arduino.fakeConnect('light')
|
|
} catch (err) {
|
|
console.error(err)
|
|
log.error(`Error connecting to fake LIGHT device`, 'SERIAL', true, true)
|
|
return false
|
|
}
|
|
log.info('Connected to fake LIGHT device', 'SERIAL', true, true)
|
|
return true
|
|
}
|
|
|
|
dev.connectDevice = async function (device, type) {
|
|
let closeSuccess
|
|
let connectSuccess
|
|
try {
|
|
closeSuccess = await arduino.close()
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
if (type === 'projector') {
|
|
dev.connected.projector = device
|
|
try {
|
|
connectSuccess = await arduino.connect('projector', device, false)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
log.info(`Connected to ${device} as PROJECTOR`, 'SERIAL', true, true)
|
|
} else if (type === 'camera') {
|
|
dev.connected.camera = device
|
|
try {
|
|
connectSuccess = await arduino.connect('camera', device, false)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
log.info(`Connected to ${device} as CAMERA`, 'SERIAL', true, true)
|
|
} else if (type === 'light') {
|
|
dev.connected.light = device
|
|
try {
|
|
connectSuccess = await arduino.connect('light', device, false)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
log.info(`Connected to ${device} as LIGHT`, 'SERIAL', true, true)
|
|
} else if (type === 'projector,light') {
|
|
dev.connected.projector = device
|
|
dev.connected.light = device
|
|
arduino.aliasSerial('light', device)
|
|
try{
|
|
connectSuccess = await arduino.connect('projector', device, false)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
log.info(`Connected to ${device} as PROJECTOR + LIGHT`, 'SERIAL', true, true)
|
|
|
|
} else if (type === 'projector,camera,light') {
|
|
dev.connected.projector = device
|
|
dev.connected.camera = device
|
|
dev.connected.light = device
|
|
arduino.aliasSerial('camera', device)
|
|
arduino.aliasSerial('light', device)
|
|
try {
|
|
connectSuccess = await arduino.connect('projector', device, false)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
log.info(`Connected to ${device} as PROJECTOR + CAMERA + LIGHT`, 'SERIAL', true, true)
|
|
|
|
} else if (type === 'projector,camera') {
|
|
dev.connected.projector = device
|
|
dev.connected.camera = device
|
|
arduino.aliasSerial('camera', device)
|
|
try {
|
|
connectSuccess = await arduino.connect('projector', device, false)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
log.info(`Connected to ${device} as PROJECTOR`, 'SERIAL', true, true)
|
|
} else if (type === 'projector_second') {
|
|
dev.connected.projector_second = device
|
|
arduino.aliasSerial('projector_second', device)
|
|
try {
|
|
connectSuccess = await arduino.connect('projector_second', device, false)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return false
|
|
}
|
|
}
|
|
return connectSuccess
|
|
}
|
|
|
|
//Cases for 1 or 2 arduinos connected
|
|
dev.all = async function (devices) {
|
|
let c = {}
|
|
let p = {}
|
|
let l = {}
|
|
let type
|
|
let d
|
|
let s = {}
|
|
|
|
|
|
dev.connected = {
|
|
projector : false,
|
|
camera : false,
|
|
light : false,
|
|
projector_second : false
|
|
}
|
|
|
|
let checklist = []
|
|
|
|
for (let device of devices) {
|
|
try {
|
|
type = await dev.distinguish(device)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return reject(err)
|
|
}
|
|
|
|
try {
|
|
await dev.connectDevice(device, type)
|
|
} catch (err) {
|
|
console.error(err)
|
|
return reject(err)
|
|
}
|
|
}
|
|
|
|
//done checking devices
|
|
|
|
if (!dev.connected.projector) {
|
|
await dev.fakeProjector()
|
|
}
|
|
p.arduino = dev.connected.projector
|
|
if (!dev.connected.camera) {
|
|
await dev.fakeCamera()
|
|
}
|
|
c.arduino = dev.connected.camera
|
|
|
|
if (mcopy.settings.camera.intval) {
|
|
c.intval = mcopy.settings.camera.intval
|
|
await delay(1000)
|
|
await cam.connectIntval(null, { connect : true, url : c.intval })
|
|
}
|
|
|
|
if (!dev.connected.light) {
|
|
await dev.fakeLight()
|
|
}
|
|
|
|
l.arduino = dev.connected.light
|
|
|
|
if (dev.connected.projector_second) {
|
|
s = dev.connected.projector_second
|
|
}
|
|
|
|
return dev.ready(p, c, l, s)
|
|
}
|
|
|
|
dev.remember = function (which, device, type) {
|
|
let deviceEntry
|
|
const match = mcopy.settings.devices.filter(dev => {
|
|
if (dev[which] && dev[which] === device) {
|
|
return dev
|
|
}
|
|
})
|
|
if (match.length === 0) {
|
|
deviceEntry = {
|
|
type : type
|
|
}
|
|
deviceEntry[which] = device
|
|
mcopy.settings.devices.push(deviceEntry)
|
|
settings.update('devices', mcopy.settings.devices)
|
|
settings.save()
|
|
}
|
|
};
|
|
|
|
dev.ready = function (projector, camera, light, projector_second) {
|
|
let args = {
|
|
camera,
|
|
projector,
|
|
light,
|
|
profile: mcopy.settings.profile
|
|
}
|
|
if (projector_second && projector_second.arduino) {
|
|
args.projector_second = projector_second
|
|
}
|
|
mainWindow.webContents.send('ready', args)
|
|
settings.update('camera', camera)
|
|
settings.update('projector', projector)
|
|
settings.update('light', light)
|
|
if (projector_second && projector_second.arduino) {
|
|
settings.update('projector_second', projector_second)
|
|
mainWindow.setSize(800, 800)
|
|
}
|
|
settings.save()
|
|
return true
|
|
};
|
|
|
|
var createMenu = function () {
|
|
const template = require('./data/menu.json')
|
|
menu = Menu.buildFromTemplate(template)
|
|
Menu.setApplicationMenu(menu)
|
|
}
|
|
|
|
var createWindow = function () {
|
|
mainWindow = new BrowserWindow({
|
|
width: 800,
|
|
height: 600,
|
|
minWidth : 800,
|
|
minHeight : 600,
|
|
icon: path.join(__dirname, 'assets/icons/icon.png')
|
|
})
|
|
mainWindow.loadURL('file://' + __dirname + '/index.html')
|
|
if (process.argv.indexOf('-d') !== -1 || process.argv.indexOf('--dev') !== -1) {
|
|
mainWindow.webContents.openDevTools()
|
|
}
|
|
mainWindow.on('closed', () => {
|
|
mainWindow = null
|
|
})
|
|
}
|
|
|
|
light.state = {
|
|
color : [0, 0, 0]
|
|
}
|
|
|
|
light.init = function () {
|
|
light.listen()
|
|
}
|
|
light.listen = function () {
|
|
ipcMain.on('light', async (event, arg) => {
|
|
try {
|
|
await light.set(arg.rgb, arg.id)
|
|
}catch (err) {
|
|
console.error(err)
|
|
return reject(err)
|
|
}
|
|
event.returnValue = true
|
|
})
|
|
}
|
|
light.set = async function (rgb, id, on) {
|
|
const str = rgb.join(',');
|
|
let ms
|
|
light.state.color = rgb;
|
|
try {
|
|
ms = arduino.send('light', mcopy.cfg.arduino.cmd.light)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
await delay(1)
|
|
try {
|
|
arduino.string('light', str)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
await delay(1)
|
|
await ms
|
|
return await light.end(rgb, id, ms)
|
|
}
|
|
light.end = async function (rgb, id, ms) {
|
|
log.info('Light set to ' + rgb.join(','), 'LIGHT', true, true)
|
|
return await mainWindow.webContents.send('light', { rgb: rgb, id : id, ms: ms })
|
|
}
|
|
|
|
proj.state = {
|
|
dir : true, //default dir
|
|
digital : false
|
|
}
|
|
proj.init = function () {
|
|
proj.listen()
|
|
}
|
|
proj.set = async function (dir, id) {
|
|
let cmd
|
|
let ms
|
|
if (dir) {
|
|
cmd = mcopy.cfg.arduino.cmd.proj_forward
|
|
} else {
|
|
cmd = mcopy.cfg.arduino.cmd.proj_backward
|
|
}
|
|
proj.state.dir = dir
|
|
if (proj.state.digital) {
|
|
dig.set(dir)
|
|
} else {
|
|
try {
|
|
ms = await arduino.send('projector', cmd)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
return await proj.end(cmd, id, ms)
|
|
}
|
|
proj.move = async function (frame, id) {
|
|
const cmd = mcopy.cfg.arduino.cmd.projector
|
|
let ms
|
|
if (proj.digital) {
|
|
try {
|
|
ms = await dig.move()
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
} else {
|
|
try {
|
|
ms = await arduino.send('projector', cmd)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
return await proj.end(mcopy.cfg.arduino.cmd.projector, id, ms)
|
|
}
|
|
proj.listen = function () {
|
|
ipcMain.on('proj', async (event, arg) => {
|
|
if (typeof arg.dir !== 'undefined') {
|
|
try {
|
|
await proj.set(arg.dir, arg.id)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
} else if (typeof arg.frame !== 'undefined') {
|
|
try {
|
|
await proj.move(arg.frame, arg.id)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
} else if (typeof arg.val !== 'undefined') {
|
|
dig.state.frame = arg.val
|
|
}
|
|
event.returnValue = true
|
|
})
|
|
ipcMain.on('digital', proj.connectDigital)
|
|
}
|
|
proj.end = async function (cmd, id, ms) {
|
|
let message = ''
|
|
if (cmd === mcopy.cfg.arduino.cmd.proj_forward) {
|
|
message = 'Projector set to FORWARD'
|
|
} else if (cmd === mcopy.cfg.arduino.cmd.proj_backward) {
|
|
message = 'Projector set to BACKWARD'
|
|
} else if (cmd === mcopy.cfg.arduino.cmd.projector) {
|
|
message = 'Projector '
|
|
if (proj.state.dir) {
|
|
message += 'ADVANCED'
|
|
} else {
|
|
message += 'REWOUND'
|
|
}
|
|
message += ' 1 frame'
|
|
}
|
|
log.info(message, 'PROJECTOR', true, true)
|
|
return await mainWindow.webContents.send('proj', {cmd: cmd, id : id, ms: ms})
|
|
}
|
|
|
|
/**
|
|
* Use a file as the "digital" source on "projector"
|
|
*
|
|
**/
|
|
proj.connectDigital = async function (evt, arg) {
|
|
let info;
|
|
let frames = 0;
|
|
|
|
try {
|
|
info = await ffprobe.info(arg.path);
|
|
} catch (err) {
|
|
log.error(err, 'DIGITAL', true, true);
|
|
proj.digital = false;
|
|
await mainWindow.webContents.send('digital', { valid : false });
|
|
return false;
|
|
}
|
|
try {
|
|
frames = await ffprobe.frames(arg.path);
|
|
} catch (err) {
|
|
log.error(err, 'DIGITAL', true, true);
|
|
proj.digital = false;
|
|
await mainWindow.webContents.send('digital', { valid : false });
|
|
return false;
|
|
}
|
|
|
|
dig.state.frame = 0;
|
|
dig.state.path = arg.path;
|
|
dig.state.fileName = arg.fileName;
|
|
dig.state.frames = frames;
|
|
dig.state.info = info;
|
|
|
|
//console.dir(dig.state);
|
|
|
|
log.info(`Opened ${dig.state.fileName}`, 'DIGITAL', true, true);
|
|
log.info(`Frames : ${frames}`, 'DIGITAL', true, true);
|
|
proj.digital = true;
|
|
return await mainWindow.webContents.send('digital', { valid : true, state : JSON.stringify(dig.state) });
|
|
}
|
|
|
|
const dig = {};
|
|
dig.state = {
|
|
frame : 0,
|
|
frames : 0,
|
|
path : null,
|
|
fileName : null,
|
|
info : {},
|
|
dir : true
|
|
};
|
|
|
|
dig.set = function (dir) {
|
|
dig.state.dir = dir;
|
|
}
|
|
|
|
dig.move = async function () {
|
|
let start = +new Date()
|
|
let last = dig.state.dir + 0;
|
|
if (dig.state.dir) {
|
|
dig.state.frame++
|
|
} else {
|
|
dig.state.frame--
|
|
}
|
|
if (dig.state.frame < 1) {
|
|
dig.state.frame = 1
|
|
}
|
|
return (+new Date()) - start
|
|
}
|
|
|
|
dig.start = async function () {
|
|
try {
|
|
await ffmpeg.clearAll()
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
|
|
try {
|
|
await ffmpeg.frame(dig.state, light.state)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
|
|
display.start(dig.state.frame)
|
|
await delay(20)
|
|
}
|
|
|
|
dig.end = async function () {
|
|
await delay(20)
|
|
display.end()
|
|
}
|
|
|
|
cam.intval = null
|
|
cam.state = {
|
|
dir : true //default dir
|
|
}
|
|
cam.init = function () {
|
|
cam.listen()
|
|
}
|
|
cam.set = async function (dir, id) {
|
|
let cmd
|
|
let ms
|
|
if (dir) {
|
|
cmd = mcopy.cfg.arduino.cmd.cam_forward
|
|
} else {
|
|
cmd = mcopy.cfg.arduino.cmd.cam_backward
|
|
}
|
|
cam.state.dir = dir
|
|
|
|
if (cam.intval) {
|
|
try {
|
|
ms = await cam.intval.setDir(dir)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
} else {
|
|
try {
|
|
ms = await arduino.send('camera', cmd)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
return await cam.end(cmd, id, ms)
|
|
}
|
|
|
|
cam.move = async function (frame, id) {
|
|
const cmd = mcopy.cfg.arduino.cmd.camera
|
|
let ms
|
|
if (proj.digital) {
|
|
await dig.start()
|
|
}
|
|
if (cam.intval) {
|
|
try {
|
|
ms = await cam.intval.move()
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
} else {
|
|
try {
|
|
ms = await arduino.send('camera', cmd)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
if (proj.digital) {
|
|
await dig.end()
|
|
}
|
|
log.info('Camera move time', { ms })
|
|
return cam.end(cmd, id, ms)
|
|
}
|
|
|
|
cam.exposure = function (exposure, id) {
|
|
let cmd = 'E'
|
|
cam.intval.setDir('camera', exposure, ms => {
|
|
cam.end(cmd, id, ms)
|
|
})
|
|
}
|
|
|
|
cam.connectIntval = async function (event, arg) {
|
|
return new Promise((resolve, reject) => {
|
|
if (arg.connect) {
|
|
cam.intval = new Intval(arg.url)
|
|
cam.intval.connect((err, ms, state) => {
|
|
if (err) {
|
|
mainWindow.webContents.send('intval', { connected : false })
|
|
log.info(`Cannot connect to ${arg.url}`, 'INTVAL', true, true)
|
|
cam.intval = null
|
|
delete cam.intval
|
|
} else {
|
|
mainWindow.webContents.send('intval', { connected : true, url : arg.url, state : state })
|
|
log.info(`Connected to INTVAL3 @ ${arg.url}`, 'INTVAL', true, true)
|
|
settings.update('camera', { intval : arg.url })
|
|
settings.save()
|
|
dev.remember('intval', arg.url, 'camera')
|
|
}
|
|
return resolve(true)
|
|
})
|
|
} else if (arg.disconnect) {
|
|
cam.intval = null
|
|
return resolve(false)
|
|
}
|
|
})
|
|
}
|
|
|
|
cam.listen = function () {
|
|
ipcMain.on('cam', async (event, arg) => {
|
|
if (typeof arg.dir !== 'undefined') {
|
|
try {
|
|
await cam.set(arg.dir, arg.id)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
} else if (typeof arg.frame !== 'undefined') {
|
|
try {
|
|
await cam.move(arg.frame, arg.id)
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
event.returnValue = true
|
|
})
|
|
ipcMain.on('intval', cam.connectIntval)
|
|
}
|
|
cam.end = async function (cmd, id, ms) {
|
|
var message = ''
|
|
if (cmd === mcopy.cfg.arduino.cmd.cam_forward) {
|
|
message = 'Camera set to FORWARD'
|
|
} else if (cmd === mcopy.cfg.arduino.cmd.cam_backward) {
|
|
message = 'Camera set to BACKWARD'
|
|
} else if (cmd === mcopy.cfg.arduino.cmd.camera) {
|
|
message = 'Camera '
|
|
if (cam.state.dir) {
|
|
message += 'ADVANCED'
|
|
} else {
|
|
message += 'REWOUND'
|
|
}
|
|
message += ' 1 frame'
|
|
}
|
|
log.info(message, 'CAMERA', true, true)
|
|
mainWindow.webContents.send('cam', {cmd: cmd, id : id, ms: ms})
|
|
};
|
|
|
|
const seq = {};
|
|
seq.init = function () {
|
|
seq.listen();
|
|
}
|
|
|
|
seq.listen = function () {
|
|
ipcMain.on('seq', async (evt, arg) => {
|
|
if (arg.action === 'stop' && proj.digital) {
|
|
display.end()
|
|
}
|
|
})
|
|
}
|
|
|
|
log.file = function () {
|
|
let logPath = path.join(os.homedir(), `/.config/mcopy/`)
|
|
if (process.platform === 'darwin') {
|
|
logPath = path.join(os.homedir(), `/Library/Logs/mcopy/`)
|
|
} else if (process.platform === 'win32') {
|
|
logPath = path.join(os.homedir(), `/AppData/Roaming/mcopy/`)
|
|
}
|
|
if (!fs.existsSync(logPath)) {
|
|
fs.mkdirSync(logPath)
|
|
}
|
|
return path.join(logPath, 'mcopy.log')
|
|
}
|
|
log.time = 'MM/DD/YY-HH:mm:ss'
|
|
log.formatter = (options) => {
|
|
console.dir(options)
|
|
return options.timestamp() +' ['+ options.level.toUpperCase() +'] '+ (undefined !== options.message ? options.message : '') +
|
|
(options.meta && Object.keys(options.meta).length ? '\n\t'+ JSON.stringify(options.meta) : '' );
|
|
}
|
|
log.transport = createLogger({
|
|
transports: [
|
|
new (transports.Console)({
|
|
level: 'info',
|
|
json : false,
|
|
format : combine(
|
|
timestamp(),
|
|
colorize(),
|
|
simple()
|
|
)
|
|
}),
|
|
new (transports.File)({
|
|
filename: log.file()
|
|
})
|
|
]
|
|
})
|
|
log.init = function () {
|
|
log.listen()
|
|
}
|
|
log.display = function (obj) {
|
|
mainWindow.webContents.send('log', obj)
|
|
}
|
|
log.listen = function () {
|
|
ipcMain.on('log', (event, arg) => {
|
|
log.transport.info(`[renderer] action=${arg.action} service=${arg.service} status=${arg.status}`)
|
|
event.returnValue = true
|
|
})
|
|
}
|
|
log.info = function (action, service, status, display) {
|
|
var obj = {
|
|
action : action,
|
|
service : service,
|
|
status : status
|
|
}
|
|
log.transport.info(`[main] action=${action} service=${service} status=${status}`)
|
|
if (display) {
|
|
log.display(obj)
|
|
}
|
|
}
|
|
/*
|
|
var transfer = {}
|
|
|
|
transfer.init = function () {
|
|
transfer.listen()
|
|
};
|
|
transfer.listen = function () {
|
|
ipcMain.on('transfer', (event, arg) => {
|
|
let res = '';
|
|
//also turn on and off
|
|
if (arg.action === 'enable') {
|
|
capture.active = true
|
|
res = capture.active
|
|
} else if (arg.action === 'disable') {
|
|
capture.active = false
|
|
res = capture.active
|
|
} else if (arg.action === 'start') {
|
|
capture.start()
|
|
} else if (arg.action === 'end') {
|
|
res = capture.end()
|
|
}
|
|
event.returnValue = res
|
|
})
|
|
}
|
|
*/
|
|
var init = async function () {
|
|
|
|
try {
|
|
SYSTEM = await system()
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
|
|
createWindow()
|
|
createMenu()
|
|
|
|
await settings.restore()
|
|
mcopy.settings = await settings.all()
|
|
|
|
log.init()
|
|
light.init()
|
|
proj.init()
|
|
cam.init()
|
|
dev.init()
|
|
seq.init()
|
|
|
|
//capture = require('capture')(SYSTEM) //redundant
|
|
display = require('display')(SYSTEM)
|
|
ffmpeg = require('ffmpeg')(SYSTEM)
|
|
ffprobe = require('ffprobe')(SYSTEM)
|
|
|
|
//transfer.init()
|
|
//capture.init()
|
|
|
|
arduino = require('./lib/arduino')(mcopy.cfg, ee)
|
|
mscript = require('./lib/mscript')
|
|
|
|
|
|
|
|
await delay(2000)
|
|
try {
|
|
await dev.enumerate()
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
}
|
|
|
|
app.on('ready', init)
|
|
|
|
app.on('window-all-closed', () => {
|
|
//if (process.platform !== 'darwin') {
|
|
app.quit();
|
|
//}
|
|
});
|
|
|
|
app.on('activate', () => {
|
|
if (mainWindow === null) {
|
|
createWindow();
|
|
}
|
|
});
|
|
|
|
mcopy.relaunch = function () {
|
|
app.relaunch({args: process.argv.slice(1).concat(['--relaunch'])})
|
|
app.exit(0)
|
|
} |