914 lines
31 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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