914 lines
31 KiB
JavaScript
914 lines
31 KiB
JavaScript
const { app, BrowserWindow, Menu, Tray, nativeImage, ipcMain, dialog } = require('electron');
|
||
const path = require('path');
|
||
const net = require('net');
|
||
const { spawn } = require('child_process');
|
||
const { pathToFileURL } = require('url');
|
||
|
||
let mainWindow = null;
|
||
let tray = null;
|
||
let isQuitting = false;
|
||
let serverStarted = false;
|
||
let backendProcess = null;
|
||
let backendApp = null; // 开发模式:后端 Main 实例
|
||
let backendWS = null; // 打包模式:后端 WS 桥接
|
||
let backendWSCleanup = []; // 事件取消函数列表
|
||
let reconcileTimer = null;
|
||
let reconcilePromise = null;
|
||
|
||
const MAIN_FILE = path.join(__dirname, '..', 'views', 'index.html');
|
||
const BACKEND_RUNNER_ARG = '--backend-runner';
|
||
const RECONCILE_INTERVAL_MS = 5000;
|
||
const APP_TITLE = '打印电脑服务';
|
||
const ICON_ICO_PATH = path.join(__dirname, 'assets', 'printserver.ico');
|
||
const ICON_PNG_PATH = path.join(__dirname, 'assets', 'printserver-icon-256.png');
|
||
const TRAY_ICON_FALLBACK_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAAV0lEQVR4AWP4TwAw/P//PwMDA8P///8ZGRkYGBgY/v//z8DAwMDA8J8B4v///5kYGRkZGBj+////PwMDw38Ghv9kZGQYGBj+////PwPDfwYGhv8MDAwA0rQYV5vWJ2EAAAAASUVORK5CYII=';
|
||
|
||
function createTrayImage() {
|
||
const icon = nativeImage.createFromPath(ICON_PNG_PATH);
|
||
if (!icon.isEmpty()) {
|
||
return icon.resize({ width: 16, height: 16 });
|
||
}
|
||
|
||
return nativeImage.createFromDataURL(TRAY_ICON_FALLBACK_DATA_URL).resize({ width: 16, height: 16 });
|
||
}
|
||
|
||
async function startLocalServer() {
|
||
if (serverStarted) {
|
||
return;
|
||
}
|
||
|
||
serverStarted = true;
|
||
const entryFile = path.join(__dirname, '..', 'index.js');
|
||
const indexModule = await import(pathToFileURL(entryFile).href);
|
||
backendApp = indexModule.default; // 获取 Main 单例
|
||
console.log('[Main] 后端已加载,services:', Object.keys(backendApp.services || {}));
|
||
}
|
||
|
||
function hasArg(flag) {
|
||
return process.argv.includes(flag);
|
||
}
|
||
|
||
function isHeadlessRunner() {
|
||
return hasArg(BACKEND_RUNNER_ARG);
|
||
}
|
||
|
||
async function loadWorkspaceModule(relativePath) {
|
||
const filePath = path.join(__dirname, '..', relativePath);
|
||
return import(pathToFileURL(filePath).href);
|
||
}
|
||
|
||
function isPortReachable(port) {
|
||
return new Promise((resolve) => {
|
||
const socket = net.createConnection({ host: '127.0.0.1', port });
|
||
let settled = false;
|
||
|
||
const finish = (result) => {
|
||
if (settled) {
|
||
return;
|
||
}
|
||
|
||
settled = true;
|
||
socket.destroy();
|
||
resolve(result);
|
||
};
|
||
|
||
socket.setTimeout(1000);
|
||
socket.once('connect', () => finish(true));
|
||
socket.once('timeout', () => finish(false));
|
||
socket.once('error', () => finish(false));
|
||
});
|
||
}
|
||
|
||
async function isBackendReady() {
|
||
try {
|
||
// 优先读运行时状态(后端实际选中的端口)
|
||
var runtimeMod = await loadWorkspaceModule('utils/runtime.js');
|
||
var rt = runtimeMod.readRuntimeState();
|
||
if (rt.wsPort) {
|
||
return isPortReachable(rt.wsPort);
|
||
}
|
||
// 降级:读配置
|
||
var config = await readRuntimeConfig();
|
||
var port = config.wsPort || 17301;
|
||
return isPortReachable(port);
|
||
} catch (_) {
|
||
return isPortReachable(17301);
|
||
}
|
||
}
|
||
|
||
// ─── 打包模式:WS 桥接(连接子进程的本地 WS 服务) ───
|
||
let _bridgeConnectPromise = null;
|
||
let _bridgeHeartbeat = null; // { pingTimer, pongTimer }
|
||
|
||
function stopBridgeHeartbeat() {
|
||
if (!_bridgeHeartbeat) return;
|
||
if (_bridgeHeartbeat.pingTimer) clearInterval(_bridgeHeartbeat.pingTimer);
|
||
if (_bridgeHeartbeat.pongTimer) clearTimeout(_bridgeHeartbeat.pongTimer);
|
||
_bridgeHeartbeat = null;
|
||
}
|
||
|
||
// 心跳:探测半开连接(休眠/唤醒后 TCP 已断但 readyState 仍为 1),超时则主动断开让周期循环重连
|
||
function startBridgeHeartbeat(ws) {
|
||
stopBridgeHeartbeat();
|
||
const state = { pingTimer: null, pongTimer: null };
|
||
state.pingTimer = setInterval(function () {
|
||
if (ws.readyState !== 1) return;
|
||
try { ws.ping(); } catch (e) { return; }
|
||
state.pongTimer = setTimeout(function () {
|
||
console.error('[Bridge] 心跳无响应,主动断开重建连接');
|
||
try { ws.terminate(); } catch (e) { /* ignore */ }
|
||
}, 10000);
|
||
}, 15000);
|
||
ws.on('pong', function () {
|
||
if (state.pongTimer) { clearTimeout(state.pongTimer); state.pongTimer = null; }
|
||
});
|
||
_bridgeHeartbeat = state;
|
||
}
|
||
|
||
// 响应超时后销毁当前桥接(可能半开),强制后续调用重建连接
|
||
function invalidateBackendBridge() {
|
||
stopBridgeHeartbeat();
|
||
if (backendWS) {
|
||
try { backendWS.terminate(); } catch (e) { /* ignore */ }
|
||
}
|
||
backendWS = null;
|
||
_bridgeConnectPromise = null;
|
||
}
|
||
|
||
async function ensureBackendBridge() {
|
||
if (!app.isPackaged || backendApp) return;
|
||
if (backendWS && backendWS.readyState === 1) return;
|
||
if (_bridgeConnectPromise) return _bridgeConnectPromise;
|
||
|
||
_bridgeConnectPromise = (async function () {
|
||
// 优先读运行时状态(后端实际选中的端口)
|
||
var wsPort;
|
||
try {
|
||
var runtimeMod = await loadWorkspaceModule('utils/runtime.js');
|
||
var rt = runtimeMod.readRuntimeState();
|
||
if (rt.wsPort) {
|
||
wsPort = rt.wsPort;
|
||
}
|
||
} catch (_) { /* ignore */ }
|
||
if (!wsPort) {
|
||
var config = await readRuntimeConfig();
|
||
wsPort = config.wsPort || 17301;
|
||
}
|
||
var mod = await import('ws');
|
||
var WebSocketImpl = mod.default || mod.WebSocket || require('ws');
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
var ws = new WebSocketImpl('ws://127.0.0.1:' + wsPort);
|
||
var connected = false;
|
||
ws.on('open', function () {
|
||
connected = true;
|
||
backendWS = ws;
|
||
console.log('[Bridge] 已连接后端 WS, port:', wsPort);
|
||
ws.on('message', function (msg) {
|
||
try {
|
||
var data = JSON.parse(msg.toString());
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.webContents.send('service:event', data);
|
||
}
|
||
} catch (e) { /* ignore */ }
|
||
});
|
||
ws.on('close', function () { stopBridgeHeartbeat(); backendWS = null; _bridgeConnectPromise = null; });
|
||
ws.on('error', function () { stopBridgeHeartbeat(); backendWS = null; _bridgeConnectPromise = null; });
|
||
startBridgeHeartbeat(ws);
|
||
resolve();
|
||
});
|
||
ws.on('error', function (err) { if (!connected) { _bridgeConnectPromise = null; reject(err); } });
|
||
setTimeout(function () { if (!connected) { _bridgeConnectPromise = null; reject(new Error('Bridge timeout')); } }, 15000);
|
||
});
|
||
})();
|
||
|
||
try { await _bridgeConnectPromise; } catch (e) {
|
||
console.error('[Bridge] 连接失败:', e.message);
|
||
_bridgeConnectPromise = null;
|
||
}
|
||
}
|
||
|
||
async function readRuntimeConfig() {
|
||
const configUtil = (await loadWorkspaceModule('utils/config.js')).default;
|
||
return configUtil.read();
|
||
}
|
||
|
||
// ────────── IPC 处理 ──────────
|
||
|
||
/**
|
||
* 调用后端服务方法(开发模式直接调用,打包模式通过内部 WS 桥接)
|
||
*/
|
||
async function handleServiceCall(method, data, allowRetry) {
|
||
// 特殊方法:获取远端 WSClient 当前状态
|
||
if (method === 'wsClient.getStatus') {
|
||
if (backendApp && backendApp.wsClient) {
|
||
return { success: true, method, result: { status: backendApp.wsClient.status, url: backendApp.wsClient.url } };
|
||
}
|
||
// 打包模式:通过桥接获取
|
||
if (backendWS && backendWS.readyState === 1) {
|
||
var _ws = backendWS;
|
||
return new Promise(function (resolve) {
|
||
var mid = method + '_' + Date.now() + '_' + Math.random().toString(36).slice(2);
|
||
var settled = false;
|
||
var handler = function (raw) {
|
||
if (settled) return;
|
||
try {
|
||
var resp = JSON.parse(raw.toString());
|
||
if (resp._msgId === mid || resp._callId === mid) {
|
||
settled = true;
|
||
if (_ws && _ws.removeListener) _ws.removeListener('message', handler);
|
||
resolve(resp);
|
||
}
|
||
} catch (e) {}
|
||
};
|
||
_ws.on('message', handler);
|
||
_ws.send(JSON.stringify({ method: method, data: data, _msgId: mid }));
|
||
setTimeout(function () {
|
||
if (settled) return;
|
||
settled = true;
|
||
if (_ws && _ws.removeListener) _ws.removeListener('message', handler);
|
||
console.error('[Bridge] 响应超时:', method);
|
||
invalidateBackendBridge();
|
||
resolve({ success: false, method: method, message: 'Bridge timeout' });
|
||
}, 30000);
|
||
});
|
||
}
|
||
return { success: false, method, message: 'WSClient not ready' };
|
||
}
|
||
|
||
// 开发模式:进程内直接调用
|
||
if (backendApp && backendApp.services) {
|
||
var methodPath = method.split('.');
|
||
var fn = backendApp.services;
|
||
for (var i = 0; i < methodPath.length; i++) {
|
||
fn = fn[methodPath[i]];
|
||
if (!fn) break;
|
||
}
|
||
if (typeof fn === 'function') {
|
||
try {
|
||
var result = await fn(data);
|
||
return { success: true, method: method, result: result };
|
||
} catch (err) {
|
||
return { success: false, method: method, message: err.message };
|
||
}
|
||
}
|
||
return { success: false, method: method, message: '服务方法未找到: ' + method };
|
||
}
|
||
|
||
// 打包模式:通过 WS 桥接转发到子进程
|
||
if (backendWS && backendWS.readyState === 1) {
|
||
var _ws2 = backendWS;
|
||
return new Promise(function (resolve) {
|
||
var mid = method + '_' + Date.now() + '_' + Math.random().toString(36).slice(2);
|
||
var settled = false;
|
||
var handler = function (raw) {
|
||
if (settled) return;
|
||
try {
|
||
var resp = JSON.parse(raw.toString());
|
||
if (resp._msgId === mid || resp._callId === mid) {
|
||
settled = true;
|
||
if (_ws2 && _ws2.removeListener) _ws2.removeListener('message', handler);
|
||
resolve(resp);
|
||
}
|
||
} catch (e) {}
|
||
};
|
||
_ws2.on('message', handler);
|
||
_ws2.send(JSON.stringify({ method: method, data: data, _msgId: mid }));
|
||
setTimeout(function () {
|
||
if (settled) return;
|
||
settled = true;
|
||
if (_ws2 && _ws2.removeListener) _ws2.removeListener('message', handler);
|
||
console.error('[Bridge] 响应超时:', method);
|
||
invalidateBackendBridge();
|
||
resolve({ success: false, method: method, message: 'Bridge timeout' });
|
||
}, 30000);
|
||
});
|
||
}
|
||
|
||
// 打包模式:桥接未就绪,尝试重新建立连接(仅重试一次,防止无限递归)
|
||
if (allowRetry !== false && app.isPackaged && !backendApp) {
|
||
await ensureBackendBridge();
|
||
if (backendWS && backendWS.readyState === 1) {
|
||
return handleServiceCall(method, data, false);
|
||
}
|
||
}
|
||
|
||
return { success: false, method: method, message: '后端尚未就绪' };
|
||
}
|
||
|
||
ipcMain.handle('service:call', async (_event, method, data) => {
|
||
return handleServiceCall(method, data, true);
|
||
});
|
||
|
||
/** 获取后端连接状态 */
|
||
ipcMain.handle('service:getBackendStatus', () => {
|
||
if (backendApp) return 'connected';
|
||
if (backendWS && backendWS.readyState === 1) return 'connected';
|
||
return 'connecting';
|
||
});
|
||
|
||
/** 获取后端 HTTP 端口 */
|
||
ipcMain.handle('service:getHttpPort', async () => {
|
||
try {
|
||
var runtimeMod = await loadWorkspaceModule('utils/runtime.js');
|
||
var rt = runtimeMod.readRuntimeState();
|
||
if (rt.httpPort) return rt.httpPort;
|
||
} catch (_) { /* ignore */ }
|
||
try {
|
||
var config = await readRuntimeConfig();
|
||
return config.httpPort || 17311;
|
||
} catch (_) {
|
||
return 17311;
|
||
}
|
||
});
|
||
|
||
/** 通过 IPC 代理调用后端 API(全模式内部直调,共享文件系统) */
|
||
ipcMain.handle('service:callApi', async (_event, apiPath, options) => {
|
||
try {
|
||
var method = (options && options.method) || 'GET';
|
||
var body = options && options.body;
|
||
var urlParams = new URLSearchParams(apiPath.includes('?') ? apiPath.split('?')[1] : '');
|
||
var pathOnly = apiPath.split('?')[0];
|
||
|
||
// /api/hikvision/files → 直接查 DB
|
||
if (pathOnly === '/api/hikvision/files' && method === 'GET') {
|
||
try {
|
||
var dbMod = await loadWorkspaceModule('utils/db.js');
|
||
var db = dbMod.default;
|
||
var page = parseInt(urlParams.get('page')) || 1;
|
||
var pageSize = Math.min(parseInt(urlParams.get('pageSize')) || 20, 100);
|
||
var search = (urlParams.get('search') || '').trim();
|
||
var offset = (page - 1) * pageSize;
|
||
|
||
var whereClause = '';
|
||
var queryParams = [];
|
||
if (search) {
|
||
whereClause = 'WHERE (ip LIKE ? OR output_path LIKE ?)';
|
||
queryParams.push('%' + search + '%', '%' + search + '%');
|
||
}
|
||
var totalRow = db.get('SELECT COUNT(*) as total FROM hik_downloads ' + whereClause, ...queryParams);
|
||
var total = totalRow ? totalRow.total : 0;
|
||
var rows = db.all('SELECT * FROM hik_downloads ' + whereClause + ' ORDER BY id DESC LIMIT ? OFFSET ?', ...queryParams, pageSize, offset);
|
||
var storageRow = db.get('SELECT COALESCE(SUM(file_size), 0) as used, COUNT(*) as fileCount FROM hik_downloads WHERE deleted = 0');
|
||
var usedBytes = storageRow ? storageRow.used : 0;
|
||
var fileCount = storageRow ? storageRow.fileCount : 0;
|
||
var hikCfg = (backendApp ? backendApp.config : await readRuntimeConfig()).hikvision || {};
|
||
var maxStorage = parseSizeToBytes(hikCfg.maxStorage || '50GB');
|
||
|
||
// 获取 HTTP 端口用于生成播放 URL
|
||
var dlPort;
|
||
try {
|
||
var rtMod = await loadWorkspaceModule('utils/runtime.js');
|
||
dlPort = rtMod.readRuntimeState().httpPort;
|
||
} catch (_) { /* ignore */ }
|
||
if (!dlPort) dlPort = (backendApp ? backendApp.config : await readRuntimeConfig()).httpPort || 17311;
|
||
|
||
return {
|
||
success: true,
|
||
data: {
|
||
list: rows.map(function (r) {
|
||
return {
|
||
...r,
|
||
downloadUrl: r.output_path ? 'http://127.0.0.1:' + dlPort + '/api/hikvision/file?path=' + encodeURIComponent(r.output_path) : null
|
||
};
|
||
}),
|
||
page: page, pageSize: pageSize, total: total,
|
||
storage: { used: usedBytes, max: maxStorage, fileCount: fileCount, percent: maxStorage > 0 ? Math.round(usedBytes / maxStorage * 100) : 0 }
|
||
}
|
||
};
|
||
} catch (e) { return { success: false, message: e.message }; }
|
||
}
|
||
|
||
// /api/hikvision/config → 直接读写 config.json
|
||
if (pathOnly === '/api/hikvision/config') {
|
||
if (method === 'GET') {
|
||
try {
|
||
var cfg = (backendApp ? backendApp.config : await readRuntimeConfig()).hikvision || {};
|
||
return { success: true, hikvision: cfg };
|
||
} catch (e) { return { success: false, message: e.message }; }
|
||
}
|
||
if (method === 'POST') {
|
||
try {
|
||
var cfgMod = await loadWorkspaceModule('utils/config.js');
|
||
var configUtil = cfgMod.default;
|
||
var currentConfig = configUtil.read();
|
||
currentConfig.hikvision = { ...(currentConfig.hikvision || {}), ...body };
|
||
configUtil.write(currentConfig);
|
||
if (backendApp) backendApp.config = currentConfig;
|
||
return { success: true, message: '配置已保存', hikvision: currentConfig.hikvision };
|
||
} catch (e) { return { success: false, message: e.message }; }
|
||
}
|
||
}
|
||
|
||
// /api/health
|
||
if (pathOnly === '/api/health' && method === 'GET') {
|
||
return { success: true, message: 'OK' };
|
||
}
|
||
|
||
// /api/hikvision/tasks → 查询 hik_tasks 表
|
||
if (pathOnly === '/api/hikvision/tasks' && method === 'GET') {
|
||
try {
|
||
var dbMod2 = await loadWorkspaceModule('utils/db.js');
|
||
var db2 = dbMod2.default;
|
||
var tPage = parseInt(urlParams.get('page')) || 1;
|
||
var tPageSize = Math.min(parseInt(urlParams.get('pageSize')) || 50, 100);
|
||
var tStatus = urlParams.get('status') || '';
|
||
var tOffset = (tPage - 1) * tPageSize;
|
||
|
||
var tWhere = '';
|
||
var tParams = [];
|
||
if (tStatus) { tWhere = 'WHERE status = ?'; tParams.push(tStatus); }
|
||
|
||
var tTotalRow = db2.get('SELECT COUNT(*) as total FROM hik_tasks ' + tWhere, ...tParams);
|
||
var tRows = db2.all('SELECT * FROM hik_tasks ' + tWhere + ' ORDER BY id DESC LIMIT ? OFFSET ?', ...tParams, tPageSize, tOffset);
|
||
|
||
return {
|
||
success: true,
|
||
data: {
|
||
list: tRows.map(function(r) {
|
||
var p = r.task_params ? JSON.parse(r.task_params) : {};
|
||
var rt = r.result ? JSON.parse(r.result) : null;
|
||
return {
|
||
id: r.id, task_id: r.task_id, unique_code: r.unique_code || '',
|
||
status: r.status,
|
||
ip: p.ip || '', channel: p.channel || 0,
|
||
speed: p.speed || 4, videoTime: p.videoTime || 0,
|
||
rec_start: p.start || '', rec_end: p.end || '',
|
||
output: p.output || '', retry: r.retry,
|
||
error_message: r.error_message, start_time: r.start_time, end_time: r.end_time,
|
||
created_at: r.created_at, progress: null, result: rt
|
||
};
|
||
}),
|
||
page: tPage, pageSize: tPageSize,
|
||
total: tTotalRow ? tTotalRow.total : 0
|
||
}
|
||
};
|
||
} catch (e) { return { success: false, message: e.message }; }
|
||
}
|
||
|
||
// /api/hikvision/retry → 重试/重录任务
|
||
if (pathOnly === '/api/hikvision/retry' && method === 'POST') {
|
||
try {
|
||
var dbMod3 = await loadWorkspaceModule('utils/db.js');
|
||
var db3 = dbMod3.default;
|
||
var taskId = (body && body.taskId) || '';
|
||
if (!taskId) return { success: false, message: '缺少 taskId' };
|
||
|
||
var task = db3.get('SELECT status FROM hik_tasks WHERE task_id = ?', taskId);
|
||
if (!task) return { success: false, message: '任务不存在' };
|
||
|
||
if (task.status === 'completed' || task.status === 'done') {
|
||
// 重录已完成任务:先删除旧文件,再重置状态
|
||
console.log('[Retry] 重录已完成任务:', taskId, '原状态:', task.status);
|
||
// 读取旧文件路径并删除
|
||
var oldRow = db3.get('SELECT tmp_file_path FROM hik_tasks WHERE task_id = ?', taskId);
|
||
if (oldRow && oldRow.tmp_file_path) {
|
||
try {
|
||
var cfgMod4 = await loadWorkspaceModule('utils/config.js');
|
||
var hikCfg = cfgMod4.default.read().hikvision || {};
|
||
var baseDir = (hikCfg.downloadDir || 'D').replace(/[\\\/]+$/, '');
|
||
if (/^[A-Za-z]$/.test(baseDir)) baseDir = baseDir + ':/hikvision_recordings';
|
||
var absPath = require('path').join(baseDir, oldRow.tmp_file_path);
|
||
if (require('fs').existsSync(absPath)) {
|
||
require('fs').unlinkSync(absPath);
|
||
console.log('[Retry] 已删除旧文件:', absPath);
|
||
}
|
||
} catch (e) { console.error('[Retry] 删除旧文件失败:', e.message); }
|
||
}
|
||
db3.run(
|
||
"UPDATE hik_tasks SET status='pending', retry=0, error_message=NULL, result=NULL, end_time=NULL, pushed=0, push_retry=0, push_next_retry_at='' WHERE task_id=?",
|
||
taskId
|
||
);
|
||
return { success: true, message: '已重新加入录制队列' };
|
||
} else if (task.status === 'failed' || task.status === 'timeout') {
|
||
console.log('[Retry] 重试失败任务:', taskId);
|
||
db3.run(
|
||
"UPDATE hik_tasks SET status='pending', retry=retry+1, error_message=NULL WHERE task_id=?",
|
||
taskId
|
||
);
|
||
return { success: true, message: '已重新加入队列' };
|
||
} else {
|
||
return { success: false, message: '当前状态不支持重试: ' + task.status };
|
||
}
|
||
} catch (e) { return { success: false, message: e.message }; }
|
||
}
|
||
|
||
return { success: false, message: 'Unknown API: ' + pathOnly };
|
||
} catch (e) {
|
||
console.error('[callApi] error:', e.message);
|
||
return { success: false, message: e.message };
|
||
}
|
||
});
|
||
|
||
function parseSizeToBytes(sizeStr) {
|
||
var match = String(sizeStr).match(/^([\d.]+)\s*(TB|GB|MB|KB)$/i);
|
||
if (!match) return 50 * 1024 * 1024 * 1024;
|
||
var num = parseFloat(match[1]);
|
||
var multipliers = { TB: Math.pow(1024, 4), GB: Math.pow(1024, 3), MB: Math.pow(1024, 2), KB: 1024 };
|
||
return Math.round(num * (multipliers[match[2].toUpperCase()] || 1));
|
||
}
|
||
|
||
/** 打开文件夹选择对话框 */
|
||
ipcMain.handle('dialog:openFolder', async () => {
|
||
if (!mainWindow || mainWindow.isDestroyed()) return { canceled: true };
|
||
var result = await dialog.showOpenDialog(mainWindow, {
|
||
title: '选择下载目录',
|
||
properties: ['openDirectory']
|
||
});
|
||
if (result.canceled) return { canceled: true };
|
||
return { canceled: false, path: result.filePaths[0] };
|
||
});
|
||
|
||
/**
|
||
* 注册后端事件 → 渲染进程转发(替代 WSServer.onConnection / _bindAppEvents)
|
||
*/
|
||
function setupEventForwarding() {
|
||
if (!backendApp) return;
|
||
cleanupEventForwarding();
|
||
|
||
const forward = (eventMethod) => (data) => {
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.webContents.send('service:event', {
|
||
success: true,
|
||
method: eventMethod,
|
||
result: data
|
||
});
|
||
}
|
||
};
|
||
|
||
// 与 WSServer._bindAppEvents 相同的事件集
|
||
backendApp.on('printerComponentStatusChange', forward('printerComponent.statusChange'));
|
||
|
||
// wsClient 状态变化改用防抖转发,避免短暂断开/重连导致 UI 闪烁
|
||
let wsStatusDebounceTimer = null;
|
||
let wsLastForwardedStatus = null;
|
||
const forwardWsStatus = (data) => {
|
||
// error 立即转发,不防抖
|
||
if (data.status === 'error') {
|
||
if (wsStatusDebounceTimer) {
|
||
clearTimeout(wsStatusDebounceTimer);
|
||
wsStatusDebounceTimer = null;
|
||
}
|
||
wsLastForwardedStatus = data.status;
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.webContents.send('service:event', {
|
||
success: true,
|
||
method: 'wsClient.statusChange',
|
||
result: data
|
||
});
|
||
}
|
||
return;
|
||
}
|
||
if (wsStatusDebounceTimer) {
|
||
clearTimeout(wsStatusDebounceTimer);
|
||
wsStatusDebounceTimer = null;
|
||
}
|
||
// connected 立即转发;disconnected 延迟 2 秒确认
|
||
const delayMs = data.status === 'connected' ? 0 : 2000;
|
||
wsStatusDebounceTimer = setTimeout(() => {
|
||
wsStatusDebounceTimer = null;
|
||
wsLastForwardedStatus = data.status;
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.webContents.send('service:event', {
|
||
success: true,
|
||
method: 'wsClient.statusChange',
|
||
result: data
|
||
});
|
||
}
|
||
}, delayMs);
|
||
};
|
||
backendApp.on('wsClientStatusChange', forwardWsStatus);
|
||
|
||
// 推送当前 WSClient 状态(弥补监听注册前已连接的时序缺口)
|
||
if (backendApp.wsClient?.status) {
|
||
forwardWsStatus({ status: backendApp.wsClient.status, url: backendApp.wsClient.url });
|
||
}
|
||
|
||
backendApp.on('printerList', forward('printer.getWindowsPrinters'));
|
||
|
||
const generateCodeHandler = (code) => {
|
||
console.log('[IPC] generateCode 事件转发, randomCode:', code?.randomCode);
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
mainWindow.webContents.send('service:event', {
|
||
success: true,
|
||
method: 'bind.generateCode',
|
||
result: code.randomCode
|
||
});
|
||
console.log('[IPC] service:event 已发送 -> bind.generateCode');
|
||
} else {
|
||
console.log('[IPC] mainWindow 不可用, 无法转发');
|
||
}
|
||
// 码过期前 5 秒自动刷新
|
||
if (code.createdAt && code.expiresIn) {
|
||
var refreshAt = code.createdAt + code.expiresIn * 1000 - 5000;
|
||
var delay = Math.max(0, refreshAt - Date.now());
|
||
if (backendApp._codeRefreshTimer) clearTimeout(backendApp._codeRefreshTimer);
|
||
var remaining = Math.round(delay / 1000);
|
||
console.log('[IPC] 绑定码刷新定时器已设置, ' + remaining + ' 秒后触发');
|
||
backendApp._codeRefreshTimer = setTimeout(function () {
|
||
console.log('[IPC] 绑定码刷新定时器触发');
|
||
console.log('[IPC] hasToken:', !!backendApp.config?.token, 'wsClientStatus:', backendApp.wsClient?.status);
|
||
if (!backendApp.config?.token && backendApp.wsClient?.status === 'connected') {
|
||
console.log('[IPC] 请求新绑定码');
|
||
backendApp.wsClient.send({ method: 'bind.generateCode', data: {} });
|
||
} else {
|
||
console.log('[IPC] 跳过刷新: token=' + !!backendApp.config?.token + ' ws=' + backendApp.wsClient?.status);
|
||
}
|
||
}, delay);
|
||
}
|
||
};
|
||
backendApp.on('generateCode', generateCodeHandler);
|
||
|
||
backendApp.on('updateDownloadProgress', forward('update.downloadProgress'));
|
||
|
||
backendApp.on('infoChanged', forward('setting.infoChanged'));
|
||
|
||
backendApp.on('frpcStatusChange', forward('frpc.statusChange'));
|
||
|
||
backendApp.on('migrationNeeded', forward('setting.migrationNeeded'));
|
||
|
||
// ─── 主动请求绑定码(替代 WSServer.onConnection),仅首次未绑定时请求一次 ───
|
||
let bindCodeRequested = false;
|
||
const requestBindCode = () => {
|
||
if (bindCodeRequested || backendApp.config?.token) return;
|
||
bindCodeRequested = true;
|
||
|
||
if (backendApp.randomCode &&
|
||
backendApp.randomCode.createdAt + backendApp.randomCode.expiresIn * 1000 > Date.now() &&
|
||
backendApp.randomCode.randomCode) {
|
||
backendApp.emit('generateCode', backendApp.randomCode);
|
||
} else if (backendApp.wsClient?.status === 'connected') {
|
||
backendApp.randomCode = null;
|
||
backendApp.wsClient.send({ method: 'bind.generateCode', data: {} });
|
||
}
|
||
};
|
||
|
||
// 监听 WSClient 连接事件,连接后尝试请求绑定码
|
||
const wsStatusHandler = (data) => {
|
||
if (data.status === 'connected') {
|
||
requestBindCode();
|
||
}
|
||
};
|
||
backendApp.on('wsClientStatusChange', wsStatusHandler);
|
||
|
||
// 如果 WSClient 已连接,立即尝试
|
||
if (backendApp.wsClient?.status === 'connected') {
|
||
requestBindCode();
|
||
}
|
||
|
||
backendWSCleanup = [
|
||
() => backendApp.off('printerComponentStatusChange'),
|
||
() => {
|
||
if (wsStatusDebounceTimer) { clearTimeout(wsStatusDebounceTimer); wsStatusDebounceTimer = null; }
|
||
backendApp.off('wsClientStatusChange', forwardWsStatus);
|
||
},
|
||
() => backendApp.off('printerList'),
|
||
() => backendApp.off('generateCode', generateCodeHandler),
|
||
() => backendApp.off('updateDownloadProgress'),
|
||
() => backendApp.off('infoChanged'),
|
||
() => backendApp.off('frpcStatusChange'),
|
||
() => backendApp.off('migrationNeeded'),
|
||
() => backendApp.off('wsClientStatusChange', wsStatusHandler)
|
||
];
|
||
|
||
console.log('[Main] 事件转发已注册');
|
||
}
|
||
|
||
function cleanupEventForwarding() {
|
||
for (const cleanup of backendWSCleanup) {
|
||
try { cleanup(); } catch (_) { /* ignore */ }
|
||
}
|
||
backendWSCleanup = [];
|
||
if (backendApp && backendApp._codeRefreshTimer) {
|
||
clearTimeout(backendApp._codeRefreshTimer);
|
||
backendApp._codeRefreshTimer = null;
|
||
}
|
||
console.log('[Main] 事件转发已清理');
|
||
}
|
||
|
||
// 注意:本函数必须保持同步(内部无 await),否则 spawn 收到的 args 会变成 Promise 对象,
|
||
// 子进程 argv 变成 "[object Promise]",isHeadlessRunner 判定失败,因单实例锁被壳持有而秒退。
|
||
function getManagedBackendArgs() {
|
||
if (app.isPackaged) {
|
||
return [BACKEND_RUNNER_ARG];
|
||
}
|
||
|
||
return [app.getAppPath(), BACKEND_RUNNER_ARG];
|
||
}
|
||
|
||
function startManagedBackend() {
|
||
if (backendProcess || !app.isPackaged) {
|
||
return;
|
||
}
|
||
|
||
backendProcess = spawn(process.execPath, getManagedBackendArgs(), {
|
||
stdio: ['ignore', 'pipe', 'pipe'],
|
||
windowsHide: true
|
||
});
|
||
|
||
// 诊断:后端子进程输出落盘,便于排查拉起失败(stdio ignore 会丢弃崩溃信息)
|
||
try {
|
||
const fs = require('fs');
|
||
const logPath = path.join('C:\\ProgramData\\printServer', 'backend-runner.log');
|
||
const out = fs.createWriteStream(logPath, { flags: 'a' });
|
||
out.write('\n===== backend spawn ' + new Date().toISOString() + ' args=' + JSON.stringify(getManagedBackendArgs()) + ' =====\n');
|
||
backendProcess.stdout.pipe(out);
|
||
backendProcess.stderr.pipe(out);
|
||
backendProcess.once('exit', (code, sig) => {
|
||
try {
|
||
out.write('[exit] code=' + code + ' signal=' + sig + ' at=' + new Date().toISOString() + '\n');
|
||
out.end();
|
||
} catch (e) { /* ignore */ }
|
||
backendProcess = null;
|
||
});
|
||
} catch (e) {
|
||
console.error('[Backend] 诊断日志初始化失败:', e && e.message);
|
||
}
|
||
}
|
||
|
||
async function ensureDesiredBackendState() {
|
||
if (!app.isPackaged) {
|
||
await startLocalServer();
|
||
return;
|
||
}
|
||
|
||
// 打包态:桌面壳直接托管本地后端子进程(系统服务功能已移除)
|
||
const backendReady = await isBackendReady();
|
||
if (!backendReady && !backendProcess) {
|
||
startManagedBackend();
|
||
}
|
||
}
|
||
|
||
async function reconcileBackendState() {
|
||
if (reconcilePromise) {
|
||
return reconcilePromise;
|
||
}
|
||
|
||
reconcilePromise = ensureDesiredBackendState().finally(() => {
|
||
reconcilePromise = null;
|
||
});
|
||
|
||
return reconcilePromise;
|
||
}
|
||
|
||
function startReconcileLoop() {
|
||
if (reconcileTimer || !app.isPackaged) {
|
||
return;
|
||
}
|
||
|
||
reconcileTimer = setInterval(() => {
|
||
reconcileBackendState().catch((error) => {
|
||
console.error('[Runtime] 状态同步失败:', error);
|
||
});
|
||
// 同时确保 WS 桥接保持连接
|
||
ensureBackendBridge().catch((error) => {
|
||
console.error('[Bridge] 周期重连失败:', error && error.message);
|
||
});
|
||
}, RECONCILE_INTERVAL_MS);
|
||
}
|
||
|
||
function stopReconcileLoop() {
|
||
if (!reconcileTimer) {
|
||
return;
|
||
}
|
||
|
||
clearInterval(reconcileTimer);
|
||
reconcileTimer = null;
|
||
}
|
||
|
||
function showMainWindow() {
|
||
if (!mainWindow) {
|
||
return;
|
||
}
|
||
|
||
if (mainWindow.isMinimized()) {
|
||
mainWindow.restore();
|
||
}
|
||
|
||
mainWindow.show();
|
||
mainWindow.focus();
|
||
}
|
||
|
||
function loadMainPage() {
|
||
if (!mainWindow || mainWindow.isDestroyed()) {
|
||
return;
|
||
}
|
||
|
||
mainWindow.loadFile(MAIN_FILE).catch(() => {
|
||
setTimeout(loadMainPage, 1000);
|
||
});
|
||
}
|
||
|
||
function createMainWindow() {
|
||
mainWindow = new BrowserWindow({
|
||
width: 1024,
|
||
height: 720,
|
||
minWidth: 960,
|
||
minHeight: 500,
|
||
show: false,
|
||
autoHideMenuBar: true,
|
||
title: APP_TITLE,
|
||
icon: ICON_ICO_PATH,
|
||
webPreferences: {
|
||
contextIsolation: true,
|
||
nodeIntegration: false,
|
||
preload: path.join(__dirname, 'preload.cjs')
|
||
}
|
||
});
|
||
|
||
mainWindow.once('ready-to-show', () => {
|
||
mainWindow.show();
|
||
});
|
||
|
||
mainWindow.on('close', (event) => {
|
||
if (isQuitting) {
|
||
return;
|
||
}
|
||
|
||
event.preventDefault();
|
||
mainWindow.hide();
|
||
});
|
||
|
||
mainWindow.on('minimize', (event) => {
|
||
event.preventDefault();
|
||
mainWindow.hide();
|
||
});
|
||
|
||
loadMainPage();
|
||
}
|
||
|
||
function createTray() {
|
||
tray = new Tray(createTrayImage());
|
||
tray.setToolTip(APP_TITLE);
|
||
|
||
const contextMenu = Menu.buildFromTemplate([
|
||
{
|
||
label: '打开主界面',
|
||
click: () => showMainWindow()
|
||
},
|
||
{
|
||
label: '退出',
|
||
click: () => {
|
||
isQuitting = true;
|
||
app.quit();
|
||
}
|
||
}
|
||
]);
|
||
|
||
tray.setContextMenu(contextMenu);
|
||
tray.on('double-click', () => showMainWindow());
|
||
tray.on('click', () => showMainWindow());
|
||
}
|
||
|
||
async function bootstrap() {
|
||
if (isHeadlessRunner()) {
|
||
await startLocalServer();
|
||
return;
|
||
}
|
||
|
||
await reconcileBackendState();
|
||
startReconcileLoop();
|
||
await ensureBackendBridge(); // 打包模式:建立与后端子进程的 WS 桥接
|
||
setupEventForwarding();
|
||
createMainWindow();
|
||
createTray();
|
||
}
|
||
|
||
const singleInstanceLock = isHeadlessRunner() ? true : app.requestSingleInstanceLock();
|
||
|
||
if (!singleInstanceLock) {
|
||
app.quit();
|
||
} else {
|
||
if (!isHeadlessRunner()) {
|
||
app.on('second-instance', () => {
|
||
showMainWindow();
|
||
});
|
||
}
|
||
|
||
app.whenReady().then(bootstrap);
|
||
|
||
if (!isHeadlessRunner()) {
|
||
app.on('activate', () => {
|
||
if (BrowserWindow.getAllWindows().length === 0) {
|
||
createMainWindow();
|
||
} else {
|
||
showMainWindow();
|
||
}
|
||
});
|
||
}
|
||
|
||
app.on('before-quit', () => {
|
||
isQuitting = true;
|
||
stopReconcileLoop();
|
||
if (backendProcess) {
|
||
backendProcess.kill();
|
||
backendProcess = null;
|
||
}
|
||
});
|
||
|
||
if (!isHeadlessRunner()) {
|
||
app.on('window-all-closed', (event) => {
|
||
event.preventDefault();
|
||
});
|
||
}
|
||
} |