321 lines
11 KiB
TypeScript
321 lines
11 KiB
TypeScript
import type { WindowNames } from '@common/types'
|
|
|
|
import { CONFIG_KEYS, IPC_EVENTS, WINDOW_NAMES } from '@common/constants'
|
|
import { BrowserWindow, BrowserWindowConstructorOptions, ipcMain, IpcMainInvokeEvent, WebContentsView, type IpcMainEvent } from 'electron'
|
|
import { debounce } from '@common/utils'
|
|
import { createLogo } from '@main/utils'
|
|
|
|
import logManager from '@main/service/logger'
|
|
import configManager from '@main/service/config-service'
|
|
import themeManager from '@main/service/theme-service'
|
|
import path from 'node:path';
|
|
|
|
interface WindowState {
|
|
instance: BrowserWindow | void;
|
|
isHidden: boolean;
|
|
onCreate: ((window: BrowserWindow) => void)[];
|
|
onClosed: ((window: BrowserWindow) => void)[];
|
|
}
|
|
|
|
interface SizeOptions {
|
|
width: number; // 窗口宽度
|
|
height: number; // 窗口高度
|
|
maxWidth?: number; // 窗口最大宽度，可选
|
|
maxHeight?: number; // 窗口最大高度，可选
|
|
minWidth?: number; // 窗口最小宽度，可选
|
|
minHeight?: number; // 窗口最小高度，可选
|
|
}
|
|
|
|
const SHARED_WINDOW_OPTIONS = {
|
|
frame: false,
|
|
titleBarStyle: 'hidden',
|
|
trafficLightPosition: { x: -100, y: -100 },
|
|
show: false,
|
|
title: 'NIANXX',
|
|
darkTheme: themeManager.isDark,
|
|
backgroundColor: themeManager.isDark ? '#2C2C2C' : '#FFFFFF',
|
|
webPreferences: {
|
|
nodeIntegration: false, // 禁用 Node.js 集成，提高安全性
|
|
contextIsolation: true, // 启用上下文隔离，防止渲染进程访问主进程 API
|
|
sandbox: true, // 启用沙箱模式，进一步增强安全性
|
|
backgroundThrottling: false,
|
|
preload: path.join(__dirname, 'preload.js'),
|
|
},
|
|
} as BrowserWindowConstructorOptions;
|
|
|
|
class WindowService {
|
|
private static _instance: WindowService;
|
|
private _logo = createLogo();
|
|
private readonly isDev = !!MAIN_WINDOW_VITE_DEV_SERVER_URL
|
|
|
|
private _winStates: Record<WindowNames | string, WindowState> = {
|
|
main: { instance: void 0, isHidden: false, onCreate: [], onClosed: [] },
|
|
setting: { instance: void 0, isHidden: false, onCreate: [], onClosed: [] },
|
|
dialog: { instance: void 0, isHidden: false, onCreate: [], onClosed: [] },
|
|
login: { instance: void 0, isHidden: false, onCreate: [], onClosed: [] },
|
|
loading: { instance: void 0, isHidden: false, onCreate: [], onClosed: [] },
|
|
}
|
|
|
|
private constructor() {
|
|
this._setupIpcEvents();
|
|
logManager.info('WindowService initialized successfully.');
|
|
}
|
|
|
|
private _isReallyClose(windowName: WindowNames | void) {
|
|
if (windowName === WINDOW_NAMES.MAIN) return configManager.get(CONFIG_KEYS.MINIMIZE_TO_TRAY) === false;
|
|
if (windowName === WINDOW_NAMES.SETTING) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private _setupIpcEvents() {
|
|
const handleCloseWindow = (e: IpcMainEvent) => {
|
|
const target = BrowserWindow.fromWebContents(e.sender);
|
|
const winName = this.getName(target);
|
|
|
|
this.close(target, this._isReallyClose(winName));
|
|
}
|
|
|
|
const handleMinimizeWindow = (e: IpcMainEvent) => {
|
|
BrowserWindow.fromWebContents(e.sender)?.minimize();
|
|
}
|
|
|
|
const handleMaximizeWindow = (e: IpcMainEvent) => {
|
|
this.toggleMax(BrowserWindow.fromWebContents(e.sender));
|
|
}
|
|
|
|
const handleIsWindowMaximized = (e: IpcMainInvokeEvent) => {
|
|
return BrowserWindow.fromWebContents(e.sender)?.isMaximized() ?? false;
|
|
}
|
|
|
|
ipcMain.on(IPC_EVENTS.WINDOW_CLOSE, handleCloseWindow);
|
|
ipcMain.on(IPC_EVENTS.WINDOW_MINIMIZE, handleMinimizeWindow);
|
|
ipcMain.on(IPC_EVENTS.WINDOW_MAXIMIZE, handleMaximizeWindow);
|
|
ipcMain.handle(IPC_EVENTS.IS_WINDOW_MAXIMIZED, handleIsWindowMaximized);
|
|
ipcMain.handle(IPC_EVENTS.APP_LOAD_PAGE, (e: IpcMainInvokeEvent, page: string) => {
|
|
const win = BrowserWindow.fromWebContents(e.sender);
|
|
if (win) this._loadPage(win, page);
|
|
});
|
|
}
|
|
|
|
public static getInstance(): WindowService {
|
|
if (!this._instance) {
|
|
this._instance = new WindowService();
|
|
}
|
|
return this._instance;
|
|
}
|
|
|
|
public create(name: WindowNames, size: SizeOptions, moreOpts?: BrowserWindowConstructorOptions) {
|
|
if (this.get(name)) return;
|
|
const isHiddenWin = this._isHiddenWin(name);
|
|
let window = this._createWinInstance(name, { ...size, ...moreOpts });
|
|
|
|
if (this.isDev) window.webContents.openDevTools()
|
|
|
|
!isHiddenWin && this
|
|
._setupWinLifecycle(window, name)
|
|
._loadWindowTemplate(window, name)
|
|
|
|
this._listenWinReady({
|
|
win: window,
|
|
isHiddenWin,
|
|
size
|
|
})
|
|
|
|
|
|
if (!isHiddenWin) {
|
|
this._winStates[name].instance = window;
|
|
this._winStates[name].onCreate.forEach(callback => callback(window));
|
|
}
|
|
|
|
if (isHiddenWin) {
|
|
this._winStates[name].isHidden = false;
|
|
logManager.info(`Hidden window show: ${name}`)
|
|
}
|
|
|
|
return window;
|
|
}
|
|
|
|
private _setupWinLifecycle(window: BrowserWindow, name: WindowNames) {
|
|
const updateWinStatus = debounce(() => !window?.isDestroyed()
|
|
&& window?.webContents?.send(IPC_EVENTS.WINDOW_MAXIMIZE + 'back', window?.isMaximized()), 80);
|
|
window.once('closed', () => {
|
|
this._winStates[name].onClosed.forEach(callback => callback(window));
|
|
window?.destroy();
|
|
window?.removeListener('resize', updateWinStatus);
|
|
this._winStates[name].instance = void 0;
|
|
this._winStates[name].isHidden = false;
|
|
logManager.info(`Window closed: ${name}`);
|
|
});
|
|
window.on('resize', updateWinStatus)
|
|
return this;
|
|
}
|
|
|
|
private _listenWinReady(params: {
|
|
win: BrowserWindow,
|
|
isHiddenWin: boolean,
|
|
size: SizeOptions,
|
|
}) {
|
|
const onReady = () => {
|
|
params.win?.once('show', () => setTimeout(() => this._applySizeConstraints(params.win, params.size), 2));
|
|
|
|
params.win?.show();
|
|
}
|
|
|
|
if (!params.isHiddenWin) {
|
|
const loadingHandler = this._addLoadingView(params.win, params.size);
|
|
loadingHandler?.(onReady)
|
|
} else {
|
|
onReady();
|
|
}
|
|
}
|
|
|
|
private _addLoadingView(window: BrowserWindow, size: SizeOptions) {
|
|
let loadingView: WebContentsView | void = new WebContentsView();
|
|
let rendererIsReady = false;
|
|
|
|
window.contentView?.addChildView(loadingView);
|
|
loadingView.setBounds({
|
|
x: 0,
|
|
y: 0,
|
|
width: size.width,
|
|
height: size.height,
|
|
});
|
|
|
|
if (MAIN_WINDOW_VITE_DEV_SERVER_URL) {
|
|
loadingView.webContents.loadURL(`${MAIN_WINDOW_VITE_DEV_SERVER_URL}/loading.html`);
|
|
} else {
|
|
loadingView.webContents.loadFile(path.join(__dirname, `../renderer/${MAIN_WINDOW_VITE_NAME}/loading.html`));
|
|
}
|
|
|
|
const onRendererIsReady = (e: IpcMainEvent) => {
|
|
if ((e.sender !== window?.webContents) || rendererIsReady) return;
|
|
rendererIsReady = true;
|
|
window.contentView.removeChildView(loadingView as WebContentsView);
|
|
ipcMain.removeListener(IPC_EVENTS.RENDERER_IS_READY, onRendererIsReady);
|
|
loadingView = void 0;
|
|
}
|
|
ipcMain.on(IPC_EVENTS.RENDERER_IS_READY, onRendererIsReady);
|
|
|
|
return (cb: () => void) => loadingView?.webContents.once('dom-ready', () => {
|
|
loadingView?.webContents.insertCSS(`body {
|
|
background-color: ${themeManager.isDark ? '#2C2C2C' : '#FFFFFF'} !important;
|
|
--stop-color-start: ${themeManager.isDark ? '#A0A0A0' : '#7F7F7F'} !important;
|
|
--stop-color-end: ${themeManager.isDark ? '#A0A0A0' : '#7F7F7F'} !important;
|
|
}`);
|
|
cb();
|
|
})
|
|
|
|
}
|
|
|
|
private _applySizeConstraints(win: BrowserWindow, size: SizeOptions) {
|
|
if (size.maxHeight && size.maxWidth) {
|
|
win.setMaximumSize(size.maxWidth, size.maxHeight);
|
|
}
|
|
if (size.minHeight && size.minWidth) {
|
|
win.setMinimumSize(size.minWidth, size.minHeight);
|
|
}
|
|
}
|
|
|
|
private _loadPage(window: BrowserWindow, pageName: string) {
|
|
if (MAIN_WINDOW_VITE_DEV_SERVER_URL) {
|
|
return window.loadURL(`${MAIN_WINDOW_VITE_DEV_SERVER_URL}/${pageName}.html`);
|
|
}
|
|
window.loadFile(path.join(__dirname, `../renderer/${MAIN_WINDOW_VITE_NAME}/${pageName}.html`));
|
|
}
|
|
|
|
private _loadWindowTemplate(window: BrowserWindow, name: WindowNames) {
|
|
const page = name === 'main' ? 'login' : name;
|
|
this._loadPage(window, page);
|
|
}
|
|
|
|
|
|
private _handleCloseWindowState(target: BrowserWindow, really: boolean) {
|
|
const name = this.getName(target) as WindowNames;
|
|
|
|
if (name) {
|
|
if (!really) this._winStates[name].isHidden = true;
|
|
else this._winStates[name].instance = void 0;
|
|
}
|
|
|
|
setTimeout(() => {
|
|
target[really ? 'close' : 'hide']?.();
|
|
this._checkAndCloseAllWinodws();
|
|
}, 210)
|
|
}
|
|
|
|
private _checkAndCloseAllWinodws() {
|
|
if (!this._winStates[WINDOW_NAMES.MAIN].instance || this._winStates[WINDOW_NAMES.MAIN].instance?.isDestroyed())
|
|
return Object.values(this._winStates).forEach(win => win?.instance?.close());
|
|
|
|
const minimizeToTray = configManager.get(CONFIG_KEYS.MINIMIZE_TO_TRAY);
|
|
if (!minimizeToTray && !this.get(WINDOW_NAMES.MAIN)?.isVisible())
|
|
return Object.values(this._winStates).forEach(win => !win?.instance?.isVisible() && win?.instance?.close());
|
|
}
|
|
|
|
private _isHiddenWin(name: WindowNames) {
|
|
return this._winStates[name] && this._winStates[name].isHidden;
|
|
}
|
|
|
|
private _createWinInstance(name: WindowNames, opts?: BrowserWindowConstructorOptions) {
|
|
return this._isHiddenWin(name)
|
|
? this._winStates[name].instance as BrowserWindow
|
|
: new BrowserWindow({
|
|
...SHARED_WINDOW_OPTIONS,
|
|
icon: this._logo,
|
|
...opts,
|
|
});
|
|
}
|
|
|
|
public focus(target: BrowserWindow | void | null) {
|
|
if (!target) return;
|
|
const name = this.getName(target);
|
|
if (target?.isMaximized()) {
|
|
target?.restore();
|
|
logManager.debug(`Window ${name} restored and focused`);
|
|
} else {
|
|
logManager.debug(`Window ${name} focused`);
|
|
}
|
|
|
|
target?.focus();
|
|
}
|
|
|
|
public close(target: BrowserWindow | void | null, really: boolean = true) {
|
|
if (!target) return;
|
|
|
|
const name = this.getName(target);
|
|
logManager.info(`Close window: ${name}, really: ${really}`);
|
|
this._handleCloseWindowState(target, really);
|
|
}
|
|
|
|
public toggleMax(target: BrowserWindow | void | null) {
|
|
if (!target) return;
|
|
target.isMaximized() ? target.unmaximize() : target.maximize();
|
|
}
|
|
|
|
public getName(target: BrowserWindow | null | void): WindowNames | void {
|
|
if (!target) return;
|
|
for (const [name, win] of Object.entries(this._winStates) as [WindowNames, { instance: BrowserWindow | void } | void][]) {
|
|
if (win?.instance === target) return name;
|
|
}
|
|
}
|
|
|
|
public get(name: WindowNames) {
|
|
if (this._winStates[name].isHidden) return void 0;
|
|
return this._winStates[name].instance;
|
|
}
|
|
|
|
public onWindowCreate(name: WindowNames, callback: (window: BrowserWindow) => void) {
|
|
this._winStates[name].onCreate.push(callback);
|
|
}
|
|
|
|
public onWindowClosed(name: WindowNames, callback: (window: BrowserWindow) => void) {
|
|
this._winStates[name].onClosed.push(callback);
|
|
}
|
|
|
|
}
|
|
|
|
export const windowManager = WindowService.getInstance();
|
|
|
|
export default windowManager;
|