mcopy/app/main.js

529 lines
12 KiB
JavaScript
Raw Normal View History

2017-12-20 03:54:39 +00:00
'use strict'
2017-02-09 14:35:07 +00:00
2017-12-20 03:54:39 +00:00
const electron = require('electron')
const { Menu, MenuItem, ipcMain, BrowserWindow, app } = electron
2017-12-20 03:54:39 +00:00
const fs = require('fs')
const os = require('os')
2017-12-20 03:54:39 +00:00
const winston = require('winston')
const moment = require('moment')
const uuid = require('uuid')
const events = require('events')
const async = require('async')
2018-01-05 04:42:36 +00:00
const path = require('path')
2017-12-20 03:54:39 +00:00
const ee = new events.EventEmitter()
const capture = require('./lib/capture')(ee)
2018-01-05 04:42:36 +00:00
const settings = require('./lib/settings')
const Server = require('./lib/server')
const Intval = require('./lib/intval')
2017-12-20 03:54:39 +00:00
const mcopy = {}
2016-04-11 06:01:26 +00:00
2017-12-20 03:54:39 +00:00
let mainWindow
let mscript
let arduino
let intval
2017-12-20 03:54:39 +00:00
let projector
let camera
2018-01-05 04:42:36 +00:00
let server
let menu
2017-12-20 03:54:39 +00:00
let log = {}
2017-02-09 14:35:07 +00:00
//console.log(process.version)
2017-12-20 03:54:39 +00:00
2018-01-05 04:42:36 +00:00
mcopy.cfg = require('./data/cfg.json')
2018-01-21 23:53:15 +00:00
mcopy.settings = {}
var enumerateDevices = function (err, devices) {
if (err) {
log.info(err, 'SERIAL', false, true)
setTimeout(() =>{
distinguishDevices([])
}, 1000)
} else {
log.info('Found ' + devices.length + ' USB devices', 'SERIAL', true, true)
console.dir(devices)
devices = favorDevices(devices)
console.dir(devices)
distinguishDevices(devices)
}
}
var favorDevices = function (devices) {
const past = mcopy.settings.devices.filter(dev => {
if (dev.arduino) {
return dev
}
}).map(dev => {
return dev.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
}
var distinguishDevice = function (device, callback) {
var connectCb = function (err, device) {
if (err) {
return console.error(err)
}
setTimeout(function () {
arduino.verify(verifyCb)
}, 2000);
},
verifyCb = function (err, success) {
if (err) {
return console.error(err)
}
log.info(`Verified ${device} as mcopy device`, 'SERIAL', true, true)
setTimeout(function () {
arduino.distinguish(distinguishCb);
}, 1000);
},
distinguishCb = function (err, type) {
if (err) {
return console.error(err)
}
rememberDevice(device, type)
log.info(`Determined ${device} to be ${type}`, 'SERIAL', true, true)
if (callback) { callback(err, type); }
}
arduino.connect('connect', device, true, connectCb)
};
//Cases for 1 or 2 arduinos connected
var distinguishDevices = function (devices) {
2018-01-05 04:42:36 +00:00
const connected = {
projector : false,
camera : false,
light : false
}
2018-01-05 04:42:36 +00:00
let checklist = []
var fakeProjector = function () {
connected.projector = '/dev/fake'
arduino.fakeConnect('projector', () => {
log.info('Connected to fake PROJECTOR device', 'SERIAL', true, true)
})
}
var fakeCamera = function () {
connected.camera = '/dev/fake'
arduino.fakeConnect('camera', () => {
log.info('Connected to fake CAMERA device', 'SERIAL', true, true)
})
}
var fakeLight = function () {
connected.light = '/dev/fake'
arduino.fakeConnect('light', () => {
log.info('Connected to fake LIGHT device', 'SERIAL', true, true)
})
}
var distinguishCb = function (device, type, cb) {
arduino.close(() => {
2016-04-19 01:52:38 +00:00
if (type === 'projector') {
connected.projector = device
arduino.connect('projector', device, false, () => {
log.info(`Connected to ${device} as PROJECTOR`, 'SERIAL', true, true)
cb()
})
2016-04-19 01:52:38 +00:00
} else if (type === 'camera') {
connected.camera = device
arduino.connect('camera', device, false, () => {
log.info(`Connected to ${device} as CAMERA`, 'SERIAL', true, true)
cb()
})
} else if (type === 'light') {
connected.light = device
arduino.connect('light', device, false, () => {
log.info(`Connected to ${device} as LIGHT`, 'SERIAL', true, true)
cb()
})
} else if (type === 'projector,light') {
connected.projector = device
connected.light = device
arduino.connect('projector', device, false, () => {
log.info(`Connected to ${device} as PROJECTOR + LIGHT`, 'SERIAL', true, true)
cb()
})
arduino.alias('light', device)
} else if (type === 'projector,camera,light') {
connected.projector = device
connected.camera = device
connected.light = device
arduino.connect('projector', device, false, () => {
log.info(`Connected to ${device} as PROJECTOR + CAMERA + LIGHT`, 'SERIAL', true, true)
cb()
})
arduino.alias('camera', device)
arduino.alias('light', device)
} else if (type === 'projector,camera') {
connected.projector = device
connected.camera = device
arduino.connect('projector', device, false, () => {
log.info(`Connected to ${device} as PROJECTOR`, 'SERIAL', true, true)
cb()
})
arduino.alias('camera', device)
} else {
cb()
2016-04-19 01:52:38 +00:00
}
})
}
checklist = devices.map(device => {
return next => {
distinguishDevice(device, (err, type) => {
if (err) {
console.error(err)
return next()
}
distinguishCb(device, type, next)
})
}
})
async.series(checklist, () => {
//done checking devices
if (!connected.projector) {
fakeProjector()
}
if (!connected.camera) {
fakeCamera()
}
if (!connected.light) {
fakeLight()
}
devicesReady(connected.projector, connected.camera, connected.light)
})
2016-04-11 14:49:57 +00:00
};
2016-04-11 06:01:26 +00:00
var rememberDevice = function (device, type) {
let deviceEntry
let match = mcopy.settings.devices.filter(dev => {
if (dev.arduino && dev.arduino === device) {
return dev
}
})
if (match.length === 0) {
deviceEntry = {
arduino : device,
type : type
}
mcopy.settings.devices.push(deviceEntry)
settings.update('devices', mcopy.settings.devices)
settings.save()
}
}
var devicesReady = function (projector, camera, light) {
mainWindow.webContents.send('ready', {camera: camera, projector: projector, light: light })
2018-01-05 04:42:36 +00:00
settings.update('camera', { arduino : camera })
settings.update('projector', { arduino : projector })
settings.update('light', { arduino : light })
settings.save()
};
2016-04-11 14:49:57 +00:00
var createMenu = function () {
2018-01-05 04:42:36 +00:00
const template = require('./data/menu.json')
menu = Menu.buildFromTemplate(template)
Menu.setApplicationMenu(menu)
}
2016-04-11 06:01:26 +00:00
2016-04-11 14:49:57 +00:00
var createWindow = function () {
mainWindow = new BrowserWindow({
width: 800,
height: 600,
minWidth : 800,
minHeight : 600
})
mainWindow.loadURL('file://' + __dirname + '/index.html')
//mainWindow.webContents.openDevTools()
mainWindow.on('closed', () => {
mainWindow = null
2018-01-05 04:42:36 +00:00
})
2016-04-11 06:01:26 +00:00
}
var light = {}
light.init = function () {
light.listen()
};
light.listen = function () {
ipcMain.on('light', (event, arg) => {
light.set(arg.rgb, arg.id)
event.returnValue = true
})
};
light.set = function (rgb, id) {
var str = rgb.join(',');
arduino.send('light', mcopy.cfg.arduino.cmd.light, (ms) => {
light.end(rgb, id, ms)
})
arduino.string('light', str)
};
2016-04-18 04:19:09 +00:00
light.end = function (rgb, id, ms) {
log.info('Light set to ' + rgb.join(','), 'LIGHT', true, true)
mainWindow.webContents.send('light', {rgb: rgb, id : id, ms: ms})
2016-04-13 04:06:19 +00:00
};
var proj = {}
proj.state = {
dir : true //default dir
};
proj.init = function () {
proj.listen()
}
proj.set = function (dir, id) {
var cmd
if (dir) {
cmd = mcopy.cfg.arduino.cmd.proj_forward
} else {
cmd = mcopy.cfg.arduino.cmd.proj_backward
}
proj.state.dir = dir
arduino.send('projector', cmd, (ms) => {
proj.end(cmd, id, ms)
})
}
proj.move = function (frame, id) {
arduino.send('projector', mcopy.cfg.arduino.cmd.projector, (ms) => {
proj.end(mcopy.cfg.arduino.cmd.projector, id, ms)
})
}
proj.listen = function () {
ipcMain.on('proj', (event, arg) => {
if (typeof arg.dir !== 'undefined') {
proj.set(arg.dir, arg.id)
} else if (typeof arg.frame !== 'undefined') {
proj.move(arg.frame, arg.id)
}
event.returnValue = true
})
}
2016-04-18 03:02:22 +00:00
proj.end = function (cmd, id, ms) {
var 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)
mainWindow.webContents.send('proj', {cmd: cmd, id : id, ms: ms})
}
2016-04-18 03:02:22 +00:00
var cam = {
intval : null
}
2016-04-18 03:02:22 +00:00
cam.state = {
dir : true //default dir
}
2016-04-18 03:02:22 +00:00
cam.init = function () {
cam.listen()
}
2016-04-18 03:02:22 +00:00
cam.set = function (dir, id) {
let cmd
2016-04-18 03:02:22 +00:00
if (dir) {
cmd = mcopy.cfg.arduino.cmd.cam_forward
2016-04-18 03:02:22 +00:00
} else {
cmd = mcopy.cfg.arduino.cmd.cam_backward
2016-04-18 03:02:22 +00:00
}
cam.state.dir = dir
arduino.send('camera', cmd, (ms) => {
cam.end(cmd, id, ms)
})
/*
intval.setDir('camera', dir, (ms) => {
cam.end(cmd, id, ms)
})
*/
}
2018-01-05 04:42:36 +00:00
2016-04-18 03:02:22 +00:00
cam.move = function (frame, id) {
let cmd = mcopy.cfg.arduino.cmd.camera
arduino.send('camera', cmd, (ms) => {
cam.end(cmd, id, ms)
})
/*
intval.move('camera', (ms) => {
cam.end(cmd, id, ms)
})
*/
}
cam.exposure = function (exposure, id) {
intval.setDir('camera', exposure, (ms) => {
cam.end(cmd, id, ms)
})
}
2018-01-05 04:42:36 +00:00
2016-04-18 03:02:22 +00:00
cam.listen = function () {
ipcMain.on('cam', (event, arg) => {
2016-04-18 03:02:22 +00:00
if (typeof arg.dir !== 'undefined') {
cam.set(arg.dir, arg.id)
2016-04-18 03:02:22 +00:00
} else if (typeof arg.frame !== 'undefined') {
cam.move(arg.frame, arg.id)
2016-04-18 03:02:22 +00:00
}
event.returnValue = true
})
ipcMain.on('intval', (event, arg) => {
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
} else {
log.info()
}
})
} else if (arg.disconnect) {
cam.intval = null
}
})
}
2016-04-18 03:02:22 +00:00
cam.end = function (cmd, id, ms) {
var message = ''
2016-04-18 03:02:22 +00:00
if (cmd === mcopy.cfg.arduino.cmd.cam_forward) {
message = 'Camera set to FORWARD'
2016-04-18 03:02:22 +00:00
} else if (cmd === mcopy.cfg.arduino.cmd.cam_backward) {
message = 'Camera set to BACKWARD'
2016-04-18 03:02:22 +00:00
} else if (cmd === mcopy.cfg.arduino.cmd.camera) {
message = 'Camera '
2016-04-18 03:02:22 +00:00
if (cam.state.dir) {
message += 'ADVANCED'
2016-04-18 03:02:22 +00:00
} else {
message += 'REWOUND'
}
message += ' 1 frame'
2016-04-18 03:02:22 +00:00
}
log.info(message, 'CAMERA', true, true)
mainWindow.webContents.send('cam', {cmd: cmd, id : id, ms: ms})
};
2018-01-05 04:42:36 +00:00
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)
2018-01-05 04:42:36 +00:00
}
return path.join(logPath, 'mcopy.log')
}
log.time = 'MM/DD/YY-HH:mm:ss'
log.transport = new (winston.Logger)({
2016-04-13 02:55:51 +00:00
transports: [
new (winston.transports.Console)(),
new (winston.transports.File)({ filename: log.file() })
2016-04-13 02:55:51 +00:00
]
})
2016-04-13 02:51:47 +00:00
log.init = function () {
log.listen()
2018-01-05 04:42:36 +00:00
}
log.display = function (obj) {
mainWindow.webContents.send('log', obj)
2018-01-05 04:42:36 +00:00
}
2016-04-13 02:51:47 +00:00
log.listen = function () {
ipcMain.on('log', (event, arg) => {
log.transport.info('renderer', arg)
event.returnValue = true
})
2018-01-05 04:42:36 +00:00
}
log.info = function (action, service, status, display) {
var obj = {
time : moment().format(log.time),
action : action,
service : service,
status : status
}
log.transport.info('main', obj)
if (display) {
log.display(obj)
}
2018-01-05 04:42:36 +00:00
}
2016-06-21 15:05:44 +00:00
var transfer = {}
2016-06-21 19:25:46 +00:00
transfer.init = function () {
transfer.listen()
2016-06-21 19:25:46 +00:00
};
transfer.listen = function () {
ipcMain.on('transfer', (event, arg) => {
2016-06-21 19:25:46 +00:00
var res = '';
//also turn on and off
2016-06-29 16:01:17 +00:00
if (arg.action === 'enable') {
capture.active = true
res = capture.active
2016-06-29 16:01:17 +00:00
} else if (arg.action === 'disable') {
capture.active = false
res = capture.active
2016-06-29 16:01:17 +00:00
} else if (arg.action === 'start') {
capture.start()
} else if (arg.action === 'end') {
res = capture.end()
}
event.returnValue = res
})
}
2016-06-21 19:25:46 +00:00
2016-06-21 15:05:44 +00:00
var init = function () {
2018-01-05 04:42:36 +00:00
createWindow()
//createMenu()
log.init()
light.init()
proj.init()
cam.init()
2016-06-21 15:05:44 +00:00
2018-01-05 04:42:36 +00:00
//transfer.init()
//capture.init()
2016-06-21 15:05:44 +00:00
2018-01-05 20:48:10 +00:00
arduino = require('./lib/arduino')(mcopy.cfg, ee)
mscript = require('./lib/mscript')
2018-01-21 23:53:15 +00:00
2016-06-21 15:05:44 +00:00
2018-01-21 23:53:15 +00:00
settings.restore()
mcopy.settings = settings.all()
2018-01-05 04:42:36 +00:00
setTimeout( () => {
arduino.enumerate(enumerateDevices)
}, 1000)
}
2016-06-21 15:05:44 +00:00
app.on('ready', init)
2016-06-21 15:05:44 +00:00
app.on('window-all-closed', () => {
2016-06-21 15:05:44 +00:00
//if (process.platform !== 'darwin') {
app.quit();
//}
});
app.on('activate', () => {
2016-06-21 15:05:44 +00:00
if (mainWindow === null) {
createWindow();
}
});