1
void main() async {
2
  WidgetsFlutterBinding.ensureInitialized();
3
  //                    ^^^^^^^^^^^^^^^^^^
4
  // Flutter 插件需要在 runApp 前初始化绑定
5

6
  if (!kIsWeb && Platform.isWindows) {
7
    await windowManager.ensureInitialized();
8

9
    // 获取屏幕尺寸，按黄金比例缩放
10
    Display primaryDisplay = await screenRetriever.getPrimaryDisplay();
11
    Size screenSize = primaryDisplay.size;
12
    Size initialSize = Size(
13
      screenSize.width * 0.618,     // ← 黄金比例 φ ≈ 0.618
14
      screenSize.height * 0.618,
15
    );
16

17
    // 配置窗口选项
18
    WindowOptions windowOptions = WindowOptions(
19
      size: initialSize,
20
      center: true,                 // ← 居中显示
21
      title: 'Lumi Hub',
22
    );
23

24
    // 等待窗口就绪后显示
25
    windowManager.waitUntilReadyToShow(windowOptions, () async {
26
      await windowManager.setPreventClose(true);   // ← 拦截关闭事件
27
      await windowManager.show();
28
      await windowManager.focus();
29
    });
30
  }
31

32
  runApp(/* ... */);
33
}

1
class _LumiAppState extends State<LumiApp> with WindowListener, TrayListener {
2
  //                                              ^^^^^^^^^^^^^^
3
  //                              Mixin！（第 4 章学的 with 语法）
4

5
  @override
6
  void initState() {
7
    super.initState();
8
    if (!kIsWeb && Platform.isWindows) {
9
      windowManager.addListener(this);     // ← 注册窗口事件监听
10
      trayManager.addListener(this);       // ← 注册托盘事件监听
11
    }
12
  }
13

14
  @override
15
  void dispose() {
16
    if (!kIsWeb && Platform.isWindows) {
17
      trayManager.removeListener(this);    // ← 移除托盘监听
18
      windowManager.removeListener(this);  // ← 移除窗口监听
19
    }
20
    super.dispose();
21
  }
22
}

1
@override
2
Future<void> onWindowClose() async {
3
  if (_isClosing) return;                  // ← 防止重复触发
4

5
  final settings = context.read<AppSettings>();
6
  final bootstrap = context.read<BootstrapService>();
7

8
  // 1. 读取用户的关闭策略
9
  WindowCloseAction closeAction = settings.windowCloseAction;
10

11
  // 2. 如果设置为"每次都问"，弹出选择对话框
12
  if (closeAction == WindowCloseAction.ask) {
13
    closeAction = await _confirmCloseAction(settings);
14
    if (!mounted) return;
15
  }
16

17
  // 3. 执行对应操作
18
  if (closeAction == WindowCloseAction.minimize) {
19
    await windowManager.hide();            // ← 最小化到托盘
20
    return;
21
  }
22

23
  // 4. 真正退出
24
  _isClosing = true;
25
  trayManager.destroy();                   // ← 销毁托盘图标
26
  await bootstrap.handleAppExit(           // ← 清理子进程
27
    closeAstrBotOnExit: settings.closeAstrBotOnExit,
28
  );
29
  await windowManager.destroy();           // ← 销毁窗口
30
}

1
Future<void> _initTray() async {
2
  if (!Platform.isWindows) return;
3

4
  await trayManager.setIcon(
5
    'windows/runner/resources/app_icon.ico',
6
  );
7
  await trayManager.setToolTip('Lumi Hub');
8
  await _updateTrayMenu();
9
}
10

11
Future<void> _updateTrayMenu() async {
12
  final Menu menu = Menu(
13
    items: [
14
      MenuItem(key: 'show_window', label: '显示窗口'),
15
      MenuItem(key: 'exit_app', label: '完全退出'),
16
    ],
17
  );
18
  await trayManager.setContextMenu(menu);
19
}

1
// 点击托盘图标
2
@override
3
void onTrayIconMouseDown() {
4
  windowManager.show();
5
  windowManager.focus();
6
}
7

8
// 点击右键菜单项
9
@override
10
void onTrayMenuItemClick(MenuItem menuItem) async {
11
  if (menuItem.key == 'show_window') {
12
    await windowManager.show();
13
    await windowManager.focus();
14
  } else if (menuItem.key == 'exit_app') {
15
    if (_isClosing) return;
16
    final settings = context.read<AppSettings>();
17
    final bootstrap = context.read<BootstrapService>();
18
    _isClosing = true;
19
    trayManager.destroy();
20
    await bootstrap.handleAppExit(
21
      closeAstrBotOnExit: settings.closeAstrBotOnExit,
22
    );
23
    await windowManager.destroy();
24
  }
25
}

1
用户点击 ❌ 关闭按钮
2
     ↓
3
onWindowClose()
4
     ↓
5
windowCloseAction == ask?
6
     ├── yes → 弹出选择对话框 ─→ 用户选择
7
     └── no  → 使用已保存的选择
8
                    ↓
9
        ┌─── minimize ────┐        ┌──── exit ─────┐
10
        │ windowManager   │        │ _isClosing    │
11
        │   .hide()       │        │ trayManager   │
12
        │ (最小化到托盘)    │        │   .destroy()  │
13
        └─────────────────┘        │ bootstrap     │
14
                                   │   .handleExit │
15
用户点击托盘图标                     │ windowManager │
16
     ↓                             │   .destroy()  │
17
onTrayIconMouseDown()              └───────────────┘
18
     ↓
19
windowManager.show() + .focus()
20
(窗口重新出现)

1
// 同步等待进程完成（适合短命令）
2
Future<bool> _checkPythonAvailable() async {
3
  try {
4
    final result = await Process.run('python', ['--version']);
5
    //                   ^^^^^^^^^^^
6
    //    执行 `python --version`，等待完成
7

8
    if (result.exitCode == 0) {
9
      final version = result.stdout.toString().trim();
10
      //              ^^^^^^^^^^^^
11
      //    标准输出（stdout）
12
      _log('Python 版本: $version');
13
      return true;
14
    }
15

16
    _log('退出码: ${result.exitCode}', level: LogLevel.error);
17
    final err = result.stderr.toString().trim();
18
    //          ^^^^^^^^^^^^
19
    //    标准错误（stderr）
20
    if (err.isNotEmpty) {
21
      _log('错误输出: $err', level: LogLevel.error);
22
    }
23
    return false;
24
  } catch (_) {
25
    _log('无法执行 python --version', level: LogLevel.error);
26
    return false;
27
  }
28
}

1
Future<bool> _startAstrBot() async {
2
  // 1. 检查文件是否存在
3
  final mainFile = File('$astrbotRoot\\main.py');
4
  if (!await mainFile.exists()) {
5
    _log('未找到启动文件: ${mainFile.path}', level: LogLevel.error);
6
    return false;
7
  }
8

9
  try {
10
    // 2. 启动进程
11
    final process = await Process.start(
12
      'python',
13
      ['main.py'],
14
      workingDirectory: astrbotRoot,
15
      mode: ProcessStartMode.detached,    // ← 分离模式！
16
      //    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
17
      //    进程和 Dart 完全脱钩，独立运行
18
      //    即使 Dart 退出，子进程也继续运行
19
    );
20

21
    _startedAstrBotByHub = true;
22
    _astrBotPid = process.pid;            // ← 记住 PID，退出时用
23
    _log('AstrBot PID: ${process.pid}');
24
    return true;
25
  } catch (e) {
26
    _log('启动异常: $e', level: LogLevel.error);
27
    return false;
28
  }
29
}

1
Future<void> _killAstrBotByPid(int pid) async {
2
  try {
3
    final result = await Process.run('taskkill', [
4
      '/PID', pid.toString(),
5
      '/T',                          // ← 终止进程树（包括子进程）
6
      '/F',                          // ← 强制终止
7
    ]);
8

9
    if (result.exitCode == 0) {
10
      _log('已关闭 AstrBot（PID: $pid）。');
11
    } else {
12
      _log('关闭失败: ${result.stderr.toString().trim()}',
13
           level: LogLevel.error);
14
    }
15
  } catch (e) {
16
    _log('关闭异常: $e', level: LogLevel.error);
17
  }
18
}

1
// 检查文件是否存在
2
final mainFile = File('$astrbotRoot\\main.py');
3
if (!await mainFile.exists()) { /* ... */ }
4

5
// 写入文件（追加模式）
6
final file = File(_logFilePath!);
7
await file.writeAsString(
8
  '$line\n',
9
  mode: FileMode.append,       // ← 追加，不覆盖
10
  flush: true,                 // ← 立即刷盘
11
);
12

13
// 创建文件
14
if (!await file.exists()) {
15
  await file.create(recursive: true);   // ← recursive: 连同父目录一起创建
16
}

1
Future<void> _ensureLogFileReady() async {
2
  // 1. 确定基础路径
3
  String? baseDir = Platform.environment['LOCALAPPDATA'];
4
  if (baseDir == null || baseDir.isEmpty) {
5
    baseDir = Directory.systemTemp.path;   // ← 回退到临时目录
6
  }
7

8
  // 2. 创建日志目录
9
  final sep = Platform.pathSeparator;      // ← 跨平台路径分隔符
10
  final dir = Directory('$baseDir${sep}LumiHub${sep}logs');
11
  await dir.create(recursive: true);
12
  _logDirectoryPath = dir.path;
13

14
  // 3. 生成日志文件名（按日期）
15
  final now = DateTime.now();
16
  final dateStr = '${now.year}-${now.month.toString().padLeft(2, '0')}'
17
                  '-${now.day.toString().padLeft(2, '0')}';
18
  _logFilePath = '${dir.path}${sep}launcher_$dateStr.log';
19

20
  // 4. 确保文件存在
21
  final file = File(_logFilePath!);
22
  if (!await file.exists()) {
23
    await file.create(recursive: true);
24
  }
25

26
  // 5. 写入会话分隔符
27
  await _appendLogLine('---------------- new session ----------------');
28
}

1
Future<bool> _waitHostReady(Duration timeout) async {
2
  final stopwatch = Stopwatch()..start();
3
  //                            ^^^^^^^^
4
  //             级联操作符（第 3 章学的）：创建 + 启动
5

6
  while (stopwatch.elapsed < timeout) {
7
    if (await _isHostReachable()) {
8
      return true;          // ← Host 就绪，返回成功
9
    }
10
    await Future<void>.delayed(const Duration(milliseconds: 500));
11
    //                                        ^^^^^^^^^^^^^^^^^^^
12
    //                  每 500ms 检查一次（不要太频繁，避免 CPU 空转）
13
  }
14
  return false;             // ← 超时，返回失败
15
}