3233 lines
136 KiB
Dart
Executable File
3233 lines
136 KiB
Dart
Executable File
import 'dart:convert';
|
||
import 'dart:io';
|
||
import 'dart:async';
|
||
import 'dart:ffi';
|
||
// ✅ dart:isolate 已移除（原用于 DNS 恢复的 Isolate，现由 libcore 管理）
|
||
|
||
import 'package:flutter/material.dart';
|
||
import 'package:flutter/services.dart';
|
||
import 'package:fpdart/fpdart.dart';
|
||
import 'package:get/get.dart';
|
||
import 'package:synchronized/synchronized.dart';
|
||
|
||
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
||
|
||
import 'package:kaer_with_panels/singbox/service/singbox_service.dart';
|
||
import 'package:kaer_with_panels/singbox/service/singbox_service_provider.dart';
|
||
import 'package:path_provider/path_provider.dart';
|
||
import 'package:path/path.dart' as p;
|
||
|
||
import '../../../core/model/directories.dart';
|
||
import '../../../singbox/model/singbox_config_option.dart';
|
||
import '../../../singbox/model/singbox_outbound.dart';
|
||
import '../../../singbox/model/singbox_stats.dart';
|
||
import '../../../singbox/model/singbox_status.dart';
|
||
import '../../utils/kr_country_util.dart';
|
||
import '../../utils/kr_log_util.dart';
|
||
import '../../utils/kr_file_logger.dart';
|
||
import '../../utils/kr_secure_storage.dart';
|
||
// ✅ DNS 由 libcore.dll 自动管理，已移除 kr_windows_dns_util.dart
|
||
import '../../utils/kr_windows_process_util.dart';
|
||
import '../../common/app_run_data.dart';
|
||
import 'package:flutter/foundation.dart';
|
||
|
||
enum KRConnectionType {
|
||
global,
|
||
rule,
|
||
// direct,
|
||
}
|
||
|
||
// 🔧 P0-1: 订阅类型标识 - 用于精确管理订阅
|
||
class _SubscriptionType {
|
||
static const String groups = 'groups';
|
||
static const String stats = 'stats';
|
||
static const String status = 'status';
|
||
}
|
||
|
||
// 🔧 _WindowsProxyRestoreWorker 类已删除 - 改用 WinINet API 直接在主线程执行（无需 Isolate）
|
||
// 优势：
|
||
// ✅ 毫秒级速度（无进程启动开销）
|
||
// ✅ 无黑窗问题
|
||
// ✅ 代码更简洁
|
||
|
||
class KRSingBoxImp {
|
||
/// 私有构造函数
|
||
KRSingBoxImp._();
|
||
|
||
/// 单例实例
|
||
static final KRSingBoxImp _instance = KRSingBoxImp._();
|
||
|
||
/// 工厂构造函数
|
||
factory KRSingBoxImp() => _instance;
|
||
|
||
/// 获取实例的静态方法
|
||
static KRSingBoxImp get instance => _instance;
|
||
|
||
/// 配置文件目录
|
||
late Directories kr_configDics;
|
||
|
||
/// 配置文件名称
|
||
String kr_configName = "hiFastVPN";
|
||
|
||
/// 存储键：用户选择的节点
|
||
static const String _keySelectedNode = 'SELECTED_NODE_TAG';
|
||
|
||
/// 通道方法
|
||
final _kr_methodChannel = const MethodChannel("com.hi.app/platform");
|
||
|
||
final _kr_container = ProviderContainer();
|
||
|
||
/// 核心服务
|
||
late SingboxService kr_singBox;
|
||
|
||
/// more配置
|
||
Map<String, dynamic> kr_configOption = {};
|
||
|
||
List<Map<String, dynamic>> kr_outbounds = [];
|
||
|
||
/// 首次启动
|
||
RxBool kr_isFristStart = false.obs;
|
||
|
||
/// 状态
|
||
final kr_status = SingboxStatus.stopped().obs;
|
||
|
||
/// 拦截广告
|
||
final kr_blockAds = false.obs;
|
||
|
||
/// 是否自动自动选择线路
|
||
final kr_isAutoOutbound = false.obs;
|
||
|
||
/// 连接类型
|
||
final kr_connectionType = KRConnectionType.rule.obs;
|
||
|
||
String _cutPath = "";
|
||
|
||
/// 端口
|
||
int kr_port = 51213;
|
||
|
||
// Windows 下 old command server 使用固定 TCP 端口（libbox hard-coded: 127.0.0.1:8964）
|
||
static const int _krWindowsCommandServerPort = 8964;
|
||
|
||
/// 统计
|
||
final kr_stats = SingboxStats(
|
||
connectionsIn: 0,
|
||
connectionsOut: 0,
|
||
uplink: 0,
|
||
downlink: 0,
|
||
uplinkTotal: 0,
|
||
downlinkTotal: 0,
|
||
).obs;
|
||
|
||
/// 活动的出站分组
|
||
RxList<SingboxOutboundGroup> kr_activeGroups = <SingboxOutboundGroup>[].obs;
|
||
|
||
// ✅ Windows 管理员权限检查缓存（避免重复执行系统命令）
|
||
bool? _cachedAdminPrivilege;
|
||
DateTime? _cachedAdminPrivilegeTime;
|
||
static const Duration _adminPrivilegeCacheDuration = Duration(hours: 1);
|
||
|
||
// ✅ DNS 和系统代理都由 Go 后端 (libcore.dll) 自动管理
|
||
// 参考 Hiddify 实现：Dart 层不再手动处理 DNS 和代理设置
|
||
// sing-box 内部有完整的 DNS 代理机制（local-dns-port、remote-dns-address 等）
|
||
|
||
/// 所有的出站分组
|
||
RxList<SingboxOutboundGroup> kr_allGroups = <SingboxOutboundGroup>[].obs;
|
||
|
||
/// Stream 订阅管理器
|
||
final List<StreamSubscription<dynamic>> _kr_subscriptions = [];
|
||
|
||
// 🔧 P0-1 + P2-11: 改进订阅管理 - 使用 Map 而非 List，防止重复订阅
|
||
// P2-11: hashCode 去重不可靠 - 改为使用类型安全的 Map，避免基于 hashCode.toString().contains() 的脆弱判断
|
||
/// 精确的订阅管理（Map）
|
||
final Map<String, StreamSubscription<dynamic>> _subscriptionMap = {};
|
||
|
||
// ✅ 系统代理操作已移交给 Go 后端 (libcore.dll) 处理
|
||
// 不再需要 Dart 层的代理操作互斥锁
|
||
|
||
/// 初始化标志，防止重复初始化
|
||
bool _kr_isInitialized = false;
|
||
|
||
// 🔧 P1-3: 命令客户端初始化锁，防止并发调用导致重复初始化
|
||
final Lock _commandClientInitLock = Lock();
|
||
|
||
// 🔧 防止 kr_start() 和 kr_stop() 并发执行导致卡顿
|
||
// 快速点击VPN开关时，通过此 Lock 确保上一个操作完成后才能开始新操作
|
||
final Lock _startStopLock = Lock();
|
||
|
||
// 【关键】停止请求标志
|
||
// 用于通知后台任务停止执行，避免竞态条件
|
||
// 当 kr_stop() 开始时设置为 true，让正在执行或即将执行的后台任务立即返回
|
||
bool _stopRequested = false;
|
||
|
||
// ✅ DNS 相关的方法已移除
|
||
// 参考 Hiddify 实现：sing-box 内部有完整的 DNS 代理机制
|
||
// 通过 local-dns-port、remote-dns-address、direct-dns-address 等配置处理 DNS
|
||
|
||
/// 当前混合代理端口是否就绪
|
||
bool get kr_isProxyReady => kr_status.value is SingboxStarted;
|
||
|
||
String? _lastProxyRule;
|
||
|
||
/// 构建 Dart HttpClient 可识别的代理规则字符串
|
||
///
|
||
/// 当 sing-box 尚未启动时返回 `DIRECT`，启动后返回
|
||
/// `PROXY 127.0.0.1:<port>`，可选附加 DIRECT 回落。
|
||
String kr_buildProxyRule({bool includeDirectFallback = false}) {
|
||
if (!kr_isProxyReady) {
|
||
const directRule = 'DIRECT';
|
||
if (_lastProxyRule != directRule) {
|
||
KRLogUtil.kr_i('⏳ sing-box 未就绪，使用 DIRECT 直连', tag: 'SingBox');
|
||
_lastProxyRule = directRule;
|
||
}
|
||
return directRule;
|
||
}
|
||
final proxyRule = StringBuffer('PROXY 127.0.0.1:$kr_port');
|
||
if (includeDirectFallback) {
|
||
proxyRule.write('; DIRECT');
|
||
}
|
||
final ruleString = proxyRule.toString();
|
||
if (_lastProxyRule != ruleString) {
|
||
KRLogUtil.kr_i('🛠️ 使用代理规则: $ruleString', tag: 'SingBox');
|
||
_lastProxyRule = ruleString;
|
||
}
|
||
return ruleString;
|
||
}
|
||
|
||
/// 初始化
|
||
Future<void> init() async {
|
||
// 防止重复初始化
|
||
if (_kr_isInitialized) {
|
||
KRLogUtil.kr_i('SingBox 已经初始化，跳过重复初始化', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
KRLogUtil.kr_i('开始初始化 SingBox');
|
||
// 在应用启动时初始化
|
||
await KRCountryUtil.kr_init();
|
||
KRLogUtil.kr_i('国家工具初始化完成');
|
||
|
||
final oOption = SingboxConfigOption.fromJson(_getConfigOption());
|
||
KRLogUtil.kr_i('配置选项初始化完成');
|
||
|
||
KRLogUtil.kr_i('开始初始化 SingBox 服务');
|
||
kr_singBox = await _kr_container.read(singboxServiceProvider);
|
||
await _kr_container.read(singboxServiceProvider).init();
|
||
KRLogUtil.kr_i('SingBox 服务初始化完成');
|
||
|
||
KRLogUtil.kr_i('开始初始化目录');
|
||
|
||
/// 初始化目录
|
||
if (Platform.isIOS) {
|
||
final paths = await _kr_methodChannel.invokeMethod<Map>("get_paths");
|
||
KRLogUtil.kr_i('iOS 路径获取完成: $paths');
|
||
|
||
kr_configDics = (
|
||
baseDir: Directory(paths?["base"]! as String),
|
||
workingDir: Directory(paths?["working"]! as String),
|
||
tempDir: Directory(paths?["temp"]! as String),
|
||
);
|
||
} else {
|
||
final baseDir = await getApplicationSupportDirectory();
|
||
final workingDir =
|
||
Platform.isAndroid ? await getExternalStorageDirectory() : baseDir;
|
||
final tempDir = await getTemporaryDirectory();
|
||
|
||
// Windows 路径规范化：确保使用正确的路径分隔符
|
||
Directory normalizePath(Directory dir) {
|
||
if (Platform.isWindows) {
|
||
final normalized = dir.path.replaceAll('/', '\\');
|
||
if (normalized != dir.path) {
|
||
KRLogUtil.kr_i('路径规范化: ${dir.path} -> $normalized', tag: 'SingBox');
|
||
return Directory(normalized);
|
||
}
|
||
}
|
||
return dir;
|
||
}
|
||
|
||
kr_configDics = (
|
||
baseDir: normalizePath(baseDir),
|
||
workingDir: normalizePath(workingDir!),
|
||
tempDir: normalizePath(tempDir),
|
||
);
|
||
KRLogUtil.kr_i('其他平台路径初始化完成');
|
||
}
|
||
|
||
KRLogUtil.kr_i('开始创建目录');
|
||
KRLogUtil.kr_i('baseDir: ${kr_configDics.baseDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_i('workingDir: ${kr_configDics.workingDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_i('tempDir: ${kr_configDics.tempDir.path}', tag: 'SingBox');
|
||
|
||
// 确保所有目录都存在
|
||
if (!kr_configDics.baseDir.existsSync()) {
|
||
await kr_configDics.baseDir.create(recursive: true);
|
||
KRLogUtil.kr_i('已创建 baseDir', tag: 'SingBox');
|
||
}
|
||
if (!kr_configDics.workingDir.existsSync()) {
|
||
await kr_configDics.workingDir.create(recursive: true);
|
||
KRLogUtil.kr_i('已创建 workingDir', tag: 'SingBox');
|
||
}
|
||
if (!kr_configDics.tempDir.existsSync()) {
|
||
await kr_configDics.tempDir.create(recursive: true);
|
||
KRLogUtil.kr_i('已创建 tempDir', tag: 'SingBox');
|
||
}
|
||
|
||
// 创建 libcore 数据库所需的 data 目录（在 workingDir 下）
|
||
// 注意：libcore 的 Setup 会调用 os.Chdir(workingPath)，所以 data 目录必须在 workingDir 下
|
||
final dataDir = Directory(p.join(kr_configDics.workingDir.path, 'data'));
|
||
|
||
// 强制确保 data 目录存在（Windows 可能需要多次尝试）
|
||
int retryCount = 0;
|
||
const maxRetries = 5;
|
||
while (!dataDir.existsSync() && retryCount < maxRetries) {
|
||
try {
|
||
await dataDir.create(recursive: true);
|
||
// 等待文件系统同步（Windows 上可能需要一点时间）
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
|
||
// 验证目录确实创建成功
|
||
if (dataDir.existsSync()) {
|
||
KRLogUtil.kr_i('✅ 已创建 data 目录: ${dataDir.path}', tag: 'SingBox');
|
||
break;
|
||
} else {
|
||
retryCount++;
|
||
KRLogUtil.kr_i('⚠️ data 目录创建后验证失败，重试 $retryCount/$maxRetries', tag: 'SingBox');
|
||
await Future.delayed(const Duration(milliseconds: 200));
|
||
}
|
||
} catch (e) {
|
||
retryCount++;
|
||
KRLogUtil.kr_e('❌ 创建 data 目录失败 (尝试 $retryCount/$maxRetries): $e', tag: 'SingBox');
|
||
if (retryCount >= maxRetries) {
|
||
throw Exception('无法创建 libcore 数据库目录: ${dataDir.path}，错误: $e');
|
||
}
|
||
final delayMs = 200 * retryCount;
|
||
await Future.delayed(Duration(milliseconds: delayMs));
|
||
}
|
||
}
|
||
|
||
if (!dataDir.existsSync()) {
|
||
final error = 'data 目录不存在: ${dataDir.path}';
|
||
KRLogUtil.kr_e('❌ $error', tag: 'SingBox');
|
||
throw Exception(error);
|
||
}
|
||
|
||
// 验证目录权限（尝试创建一个测试文件）
|
||
try {
|
||
final testFile = File(p.join(dataDir.path, '.test_write'));
|
||
await testFile.writeAsString('test');
|
||
await testFile.delete();
|
||
KRLogUtil.kr_i('✅ data 目录写入权限验证通过', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('⚠️ data 目录写入权限验证失败: $e', tag: 'SingBox');
|
||
// 不抛出异常，让 libcore 自己处理
|
||
}
|
||
|
||
// 在 Windows 上额外等待，确保文件系统操作完成
|
||
if (Platform.isWindows) {
|
||
await Future.delayed(const Duration(milliseconds: 300));
|
||
KRLogUtil.kr_i('⏳ Windows 文件系统同步等待完成', tag: 'SingBox');
|
||
}
|
||
|
||
// 最终验证：在 setup() 之前再次确认 workingDir 和 data 目录都存在且可访问
|
||
// libcore 的 Setup() 会调用 os.Chdir(workingPath)，然后使用相对路径 "./data"
|
||
// 如果 os.Chdir() 失败（路径不存在或权限问题），后续的相对路径访问会失败
|
||
if (!kr_configDics.workingDir.existsSync()) {
|
||
final error = '❌ workingDir 不存在，无法调用 setup(): ${kr_configDics.workingDir.path}';
|
||
KRLogUtil.kr_e(error, tag: 'SingBox');
|
||
throw Exception(error);
|
||
}
|
||
|
||
// 验证 workingDir 可读可写
|
||
try {
|
||
final testWorkingFile = File(p.join(kr_configDics.workingDir.path, '.test_working_dir'));
|
||
await testWorkingFile.writeAsString('test');
|
||
await testWorkingFile.delete();
|
||
KRLogUtil.kr_i('✅ workingDir 写入权限验证通过', tag: 'SingBox');
|
||
} catch (e) {
|
||
final error = '❌ workingDir 无写入权限: ${kr_configDics.workingDir.path}, 错误: $e';
|
||
KRLogUtil.kr_e(error, tag: 'SingBox');
|
||
throw Exception(error);
|
||
}
|
||
|
||
final finalDataDir = Directory(p.join(kr_configDics.workingDir.path, 'data'));
|
||
if (!finalDataDir.existsSync()) {
|
||
KRLogUtil.kr_e('❌ 最终验证失败：data 目录不存在', tag: 'SingBox');
|
||
KRLogUtil.kr_e('路径: ${finalDataDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_e('workingDir 是否存在: ${kr_configDics.workingDir.existsSync()}', tag: 'SingBox');
|
||
if (kr_configDics.workingDir.existsSync()) {
|
||
try {
|
||
final workingDirContents = kr_configDics.workingDir.listSync();
|
||
KRLogUtil.kr_e('workingDir 内容: ${workingDirContents.map((e) => e.path.split(Platform.pathSeparator).last).join(", ")}', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('无法列出 workingDir 内容: $e', tag: 'SingBox');
|
||
}
|
||
}
|
||
throw Exception('data 目录在 setup() 前验证失败: ${finalDataDir.path}');
|
||
}
|
||
|
||
// 再次尝试写入测试，确保目录确实可用
|
||
try {
|
||
final verifyFile = File(p.join(finalDataDir.path, '.verify_setup'));
|
||
await verifyFile.writeAsString('verify');
|
||
await verifyFile.delete();
|
||
KRLogUtil.kr_i('✅ setup() 前最终验证通过', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ setup() 前最终验证失败: $e', tag: 'SingBox');
|
||
// 不抛出异常，让 setup() 自己处理
|
||
}
|
||
|
||
final configsDir = Directory(p.join(kr_configDics.workingDir.path, "configs"));
|
||
if (!configsDir.existsSync()) {
|
||
try {
|
||
await configsDir.create(recursive: true);
|
||
KRLogUtil.kr_i('✅ 已创建 configs 目录: ${configsDir.path}', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('⚠️ configs 目录创建失败: $e', tag: 'SingBox');
|
||
// 不抛出异常，继续初始化
|
||
}
|
||
} else {
|
||
KRLogUtil.kr_i('✅ configs 目录已存在: ${configsDir.path}', tag: 'SingBox');
|
||
}
|
||
|
||
// 特别处理 extensionData.db 文件 (Windows特定)
|
||
if (Platform.isWindows) {
|
||
try {
|
||
final extensionDataDbPath = p.join(finalDataDir.path, 'extensionData.db');
|
||
KRLogUtil.kr_i('👉 准备处理 extensionData.db 路径: $extensionDataDbPath', tag: 'SingBox');
|
||
|
||
// 确保 extensionData.db 的父目录存在
|
||
final extensionDataParent = Directory(p.dirname(extensionDataDbPath));
|
||
if (!extensionDataParent.existsSync()) {
|
||
await extensionDataParent.create(recursive: true);
|
||
KRLogUtil.kr_i('✅ 已创建 extensionData.db 父目录', tag: 'SingBox');
|
||
}
|
||
|
||
// 测试文件创建权限
|
||
final testFile = File(p.join(extensionDataParent.path, '.test_extension'));
|
||
await testFile.writeAsString('test');
|
||
await testFile.delete();
|
||
KRLogUtil.kr_i('✅ extensionData 目录权限验证通过', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('⚠️ extensionData 目录处理失败: $e', tag: 'SingBox');
|
||
// 不抛出异常，继续初始化
|
||
}
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ 目录创建完成', tag: 'SingBox');
|
||
KRLogUtil.kr_i('开始设置 SingBox', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - baseDir: ${kr_configDics.baseDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - workingDir: ${kr_configDics.workingDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - tempDir: ${kr_configDics.tempDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - data 目录: ${p.join(kr_configDics.workingDir.path, "data")}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - data 目录存在: ${finalDataDir.existsSync()}', tag: 'SingBox');
|
||
|
||
// 在 Windows 上，列出 data 目录内容（如果有文件）
|
||
if (Platform.isWindows && finalDataDir.existsSync()) {
|
||
try {
|
||
final dataContents = finalDataDir.listSync();
|
||
if (dataContents.isNotEmpty) {
|
||
KRLogUtil.kr_i(' - data 目录现有文件: ${dataContents.map((e) => e.path.split(Platform.pathSeparator).last).join(", ")}', tag: 'SingBox');
|
||
} else {
|
||
KRLogUtil.kr_i(' - data 目录为空', tag: 'SingBox');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e(' - 无法列出 data 目录内容: $e', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
KRLogUtil.kr_i(' - libcore 将通过 os.Chdir() 切换到: ${kr_configDics.workingDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - 然后使用相对路径 "./data" 访问数据库', tag: 'SingBox');
|
||
|
||
// Windows 特定：验证路径格式是否正确
|
||
if (Platform.isWindows) {
|
||
final workingPath = kr_configDics.workingDir.path;
|
||
if (workingPath.contains('/')) {
|
||
KRLogUtil.kr_e('⚠️ 警告：Windows 路径包含正斜杠，可能导致问题: $workingPath', tag: 'SingBox');
|
||
}
|
||
// 确保路径使用反斜杠（Windows 标准）
|
||
final normalizedPath = workingPath.replaceAll('/', '\\');
|
||
if (normalizedPath != workingPath) {
|
||
KRLogUtil.kr_e('⚠️ 路径格式可能需要规范化: $workingPath -> $normalizedPath', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
// 🔑 关键步骤：调用 setup() 将 NativePort 传递给 libcore
|
||
// 这样 libcore 才能通过 GoDart_PostCObject() 向 Dart 发送消息
|
||
await KRFileLogger.log('[黑屏调试] ⏳ 准备调用 FFI setup()...');
|
||
KRLogUtil.kr_i('📡 开始调用 setup() 注册 FFI 端口', tag: 'SingBox');
|
||
final setupStartTime = DateTime.now();
|
||
final setupResult = await kr_singBox.setup(kr_configDics, false).run();
|
||
final setupDuration = DateTime.now().difference(setupStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[黑屏调试] ✅ FFI setup() 完成: 耗时 ${setupDuration}ms');
|
||
setupResult.match(
|
||
(error) async {
|
||
await KRFileLogger.log('[黑屏调试] ❌ FFI setup() 失败: $error');
|
||
KRLogUtil.kr_e('❌ setup() 失败: $error', tag: 'SingBox');
|
||
throw Exception('FFI setup 失败: $error');
|
||
},
|
||
(_) {
|
||
KRLogUtil.kr_i('✅ setup() 成功，FFI 端口已注册', tag: 'SingBox');
|
||
},
|
||
);
|
||
|
||
KRLogUtil.kr_i('✅ SingBox 初始化完成');
|
||
|
||
// 🔧 提取 geosite 文件到 workingDir
|
||
KRLogUtil.kr_i('📦 开始提取 geosite 文件...', tag: 'SingBox');
|
||
await _kr_extractGeositeFiles();
|
||
KRLogUtil.kr_i('✅ geosite 文件提取完成', tag: 'SingBox');
|
||
|
||
_kr_isInitialized = true;
|
||
|
||
// 🔑 关键：在初始化完成后立即订阅状态变化流
|
||
// 这样可以确保 UI 始终与 libcore 的实际状态同步
|
||
_kr_subscribeToStatus();
|
||
// ✅ DNS 由 libcore.dll 自动管理，无需手动备份
|
||
KRLogUtil.kr_i('✅ 状态订阅已设置', tag: 'SingBox');
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('❌ SingBox 初始化失败: $e');
|
||
KRLogUtil.kr_e('📚 错误堆栈: $stackTrace');
|
||
|
||
// 添加额外的诊断信息
|
||
if (Platform.isWindows) {
|
||
try {
|
||
final workingDir = kr_configDics.workingDir;
|
||
final dataDir = Directory(p.join(workingDir.path, 'data'));
|
||
final configsDir = Directory(p.join(workingDir.path, 'configs'));
|
||
|
||
KRLogUtil.kr_e('🔍 Windows 路径诊断信息:', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - workingDir: ${workingDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - workingDir 存在: ${workingDir.existsSync()}', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - data 目录: ${dataDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - data 目录存在: ${dataDir.existsSync()}', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - configs 目录: ${configsDir.path}', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - configs 目录存在: ${configsDir.existsSync()}', tag: 'SingBox');
|
||
|
||
// 检查父目录内容
|
||
if (workingDir.existsSync()) {
|
||
try {
|
||
final contents = workingDir.listSync();
|
||
KRLogUtil.kr_e(' - workingDir 内容: ${contents.map((e) => "${e.path.split(Platform.pathSeparator).last}${e is Directory ? "/" : ""}").join(", ")}', tag: 'SingBox');
|
||
} catch (listErr) {
|
||
KRLogUtil.kr_e(' - 无法列出 workingDir 内容: $listErr', tag: 'SingBox');
|
||
}
|
||
}
|
||
} catch (diagErr) {
|
||
KRLogUtil.kr_e(' - 诊断信息收集失败: $diagErr', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
// 如果初始化失败，允许下次重试
|
||
_kr_isInitialized = false;
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
/// 提取 geosite 文件到 workingDir
|
||
Future<void> _kr_extractGeositeFiles() async {
|
||
try {
|
||
// 创建 geosite 目录
|
||
final geositeDir = Directory(p.join(kr_configDics.workingDir.path, 'geosite'));
|
||
if (!geositeDir.existsSync()) {
|
||
await geositeDir.create(recursive: true);
|
||
KRLogUtil.kr_i('✅ 已创建 geosite 目录: ${geositeDir.path}', tag: 'SingBox');
|
||
}
|
||
|
||
// 需要提取的文件列表
|
||
final files = ['geoip-cn.srs', 'geosite-cn.srs'];
|
||
|
||
for (final filename in files) {
|
||
final assetPath = 'assets/geosite/$filename';
|
||
final targetPath = p.join(geositeDir.path, filename);
|
||
final targetFile = File(targetPath);
|
||
|
||
// 检查文件是否已存在
|
||
if (targetFile.existsSync()) {
|
||
final fileSize = await targetFile.length();
|
||
KRLogUtil.kr_i('📄 $filename 已存在 (${fileSize} bytes), 跳过', tag: 'SingBox');
|
||
continue;
|
||
}
|
||
|
||
// 从 assets 加载文件
|
||
KRLogUtil.kr_i('📥 正在提取 $filename...', tag: 'SingBox');
|
||
final byteData = await rootBundle.load(assetPath);
|
||
final bytes = byteData.buffer.asUint8List();
|
||
|
||
// 写入文件系统
|
||
await targetFile.writeAsBytes(bytes);
|
||
final writtenSize = await targetFile.length();
|
||
|
||
KRLogUtil.kr_i('✅ 提取成功: $filename (${writtenSize} bytes)', tag: 'SingBox');
|
||
}
|
||
|
||
KRLogUtil.kr_i('🎉 所有 geosite 文件提取完成', tag: 'SingBox');
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('❌ 提取 geosite 文件失败: $e', tag: 'SingBox');
|
||
KRLogUtil.kr_e('堆栈: $stackTrace', tag: 'SingBox');
|
||
// 不抛出异常,让应用继续运行(使用远程规则集作为后备)
|
||
}
|
||
}
|
||
|
||
Map<String, dynamic> _getConfigOption() {
|
||
// 不使用缓存，每次都重新生成配置
|
||
// if (kr_configOption.isNotEmpty) {
|
||
// return kr_configOption;
|
||
// }
|
||
|
||
// 🔧 关键修复：全局代理模式下，region 强制设为 'other'，libcore 就不会生成国家直连规则
|
||
final String effectiveRegion;
|
||
if (kr_connectionType.value == KRConnectionType.global) {
|
||
effectiveRegion = 'other'; // 全局代理：不添加任何国家规则
|
||
KRLogUtil.kr_i('🌐 [全局代理模式] region 设为 other，所有流量走代理', tag: 'SingBox');
|
||
} else {
|
||
effectiveRegion = KRCountryUtil.kr_getCurrentCountryCode(); // 智能代理：使用用户选择的国家
|
||
KRLogUtil.kr_i('✅ [智能代理模式] region 设为 $effectiveRegion', tag: 'SingBox');
|
||
}
|
||
|
||
final useWindowsDnsDefaults = Platform.isWindows;
|
||
final remoteDnsAddress = useWindowsDnsDefaults
|
||
? 'udp://1.1.1.1'
|
||
: 'https://dns.google/dns-query';
|
||
final directDnsAddress = useWindowsDnsDefaults
|
||
? (effectiveRegion == 'cn' ? 'udp://223.5.5.5' : 'udp://1.1.1.1')
|
||
: 'local';
|
||
final dnsDomainStrategy = useWindowsDnsDefaults ? '' : 'prefer_ipv4';
|
||
const enableDnsRouting = true;
|
||
|
||
final op = {
|
||
"region": effectiveRegion, // 🔧 修复：根据出站模式动态设置 region
|
||
"block-ads": false, // 参考 hiddify-app: 默认关闭广告拦截
|
||
"use-xray-core-when-possible": false,
|
||
"execute-config-as-is": false, // ✅ 按 hiddify-app 方式交给 libcore 生成完整配置
|
||
"log-level": "info", // 调试阶段使用 info，生产环境改为 warn
|
||
"resolve-destination": false,
|
||
"ipv6-mode": "ipv4_only", // 参考 hiddify-app: 仅使用 IPv4 (有效值: ipv4_only, prefer_ipv4, prefer_ipv6, ipv6_only)
|
||
"remote-dns-address": remoteDnsAddress, // 使用 Google DoH，避免中转节点 DNS 死锁
|
||
"remote-dns-domain-strategy": dnsDomainStrategy,
|
||
"direct-dns-address": directDnsAddress, // 使用系统 DNS，确保中转服务器域名能被解析
|
||
"direct-dns-domain-strategy": dnsDomainStrategy,
|
||
"mixed-port": kr_port,
|
||
"tproxy-port": kr_port,
|
||
"local-dns-port": 36450,
|
||
"tun-implementation": "gvisor",
|
||
"mtu": 9000,
|
||
"strict-route": true,
|
||
"connection-test-url": "http://cp.cloudflare.com", // 参考 hiddify-app: 使用 Cloudflare 测试端点
|
||
"url-test-interval": 30,
|
||
"enable-clash-api": true,
|
||
"clash-api-port": 36756,
|
||
// 🔧 关键改动：根据连接类型选择使用 TUN 还是系统代理
|
||
// 全局代理(global) → 启用 TUN 模式（强制代理，Chrome 插件无法劫持）
|
||
// 智能代理(rule) → 使用系统代理（智能分流）
|
||
// ✅ 参考 Hiddify：Windows/macOS/Linux 全局模式都启用 TUN
|
||
"enable-tun": (Platform.isIOS || Platform.isAndroid) ||
|
||
((Platform.isWindows || Platform.isMacOS || Platform.isLinux) && kr_connectionType.value == KRConnectionType.global),
|
||
"enable-tun-service": false,
|
||
"set-system-proxy":
|
||
(Platform.isWindows || Platform.isLinux || Platform.isMacOS) &&
|
||
kr_connectionType.value != KRConnectionType.global,
|
||
"bypass-lan": false,
|
||
"allow-connection-from-lan": false,
|
||
"enable-fake-dns": false,
|
||
"enable-dns-routing": enableDnsRouting,
|
||
"independent-dns-cache": true,
|
||
"rules": [
|
||
// ✅ 自定义域名直连规则 - 添加到 HiddifyOptions.Rules 中
|
||
// 🔧 修复: 空规则列表，避免 "missing conditions" 错误
|
||
// 如果需要添加规则，必须确保所有必需字段都存在
|
||
],
|
||
"mux": {
|
||
"enable": false,
|
||
"padding": false,
|
||
"max-streams": 8,
|
||
"protocol": "h2mux"
|
||
},
|
||
"tls-tricks": {
|
||
"enable-fragment": false,
|
||
"fragment-size": "10-30",
|
||
"fragment-sleep": "2-8",
|
||
"mixed-sni-case": false,
|
||
"enable-padding": false,
|
||
"padding-size": "1-1500"
|
||
},
|
||
"warp": {
|
||
"enable": false,
|
||
"mode": "proxy_over_warp",
|
||
"wireguard-config": "",
|
||
"license-key": "",
|
||
"account-id": "",
|
||
"access-token": "",
|
||
"clean-ip": "auto",
|
||
"clean-port": 0,
|
||
"noise": "1-3",
|
||
"noise-size": "10-30",
|
||
"noise-delay": "10-30",
|
||
"noise-mode": "m4"
|
||
},
|
||
"warp2": {
|
||
"enable": false,
|
||
"mode": "proxy_over_warp",
|
||
"wireguard-config": "",
|
||
"license-key": "",
|
||
"account-id": "",
|
||
"access-token": "",
|
||
"clean-ip": "auto",
|
||
"clean-port": 0,
|
||
"noise": "1-3",
|
||
"noise-size": "10-30",
|
||
"noise-delay": "10-30",
|
||
"noise-mode": "m4"
|
||
}
|
||
};
|
||
kr_configOption = op;
|
||
|
||
// 🔧 调试日志：确认自定义规则已添加
|
||
final rules = op["rules"] as List?;
|
||
KRLogUtil.kr_i('✅ HiddifyOptions 已生成，包含 ${rules?.length ?? 0} 条自定义路由规则', tag: 'SingBox');
|
||
if (rules != null && rules.isNotEmpty) {
|
||
for (var rule in rules) {
|
||
final ruleMap = rule as Map<String, dynamic>;
|
||
KRLogUtil.kr_i(' - 规则: domains=${ruleMap["domains"]}, outbound=${ruleMap["outbound"]}', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
return op;
|
||
}
|
||
|
||
List<Map<String, dynamic>> _kr_buildHiddifyRules() {
|
||
final rules = <Map<String, dynamic>>[];
|
||
rules.add({"domains": "domain:api.hifast.biz", "outbound": "bypass"});
|
||
|
||
final nodeDomains = _kr_collectNodeDomains();
|
||
for (final d in nodeDomains) {
|
||
rules.add({"domains": "domain:$d", "outbound": "bypass"});
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ 节点域名白名单数量: ${nodeDomains.length}', tag: 'SingBox');
|
||
KRLogUtil.kr_i('✅ 节点域名白名单集合: ${jsonEncode(nodeDomains.toList())}',
|
||
tag: 'SingBox');
|
||
return rules;
|
||
}
|
||
|
||
Set<String> _kr_collectNodeDomains() {
|
||
final set = <String>{};
|
||
|
||
void addFromOutbound(Map<String, dynamic> o) {
|
||
final server = o['server']?.toString();
|
||
if (server != null &&
|
||
server.isNotEmpty &&
|
||
InternetAddress.tryParse(server) == null) {
|
||
set.add(server.toLowerCase());
|
||
}
|
||
|
||
final tls = o['tls'];
|
||
if (tls is Map) {
|
||
final sni = tls['server_name']?.toString();
|
||
if (sni != null &&
|
||
sni.isNotEmpty &&
|
||
InternetAddress.tryParse(sni) == null) {
|
||
set.add(sni.toLowerCase());
|
||
}
|
||
}
|
||
}
|
||
|
||
for (final g in kr_outbounds) {
|
||
addFromOutbound(g);
|
||
}
|
||
|
||
return set;
|
||
}
|
||
|
||
/// 订阅状态变化流
|
||
/// 参考 hiddify-app: 监听 libcore 发送的状态事件来自动更新 UI
|
||
void _kr_subscribeToStatus() {
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 _kr_subscribeToStatus 被调用，重新订阅状态流');
|
||
}
|
||
KRLogUtil.kr_i('🔵 _kr_subscribeToStatus 被调用', tag: 'SingBox');
|
||
|
||
// 取消之前的状态订阅
|
||
for (var sub in _kr_subscriptions) {
|
||
if (sub.hashCode.toString().contains('Status')) {
|
||
sub.cancel();
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 已取消旧的状态订阅');
|
||
}
|
||
}
|
||
}
|
||
_kr_subscriptions
|
||
.removeWhere((sub) => sub.hashCode.toString().contains('Status'));
|
||
|
||
_kr_subscriptions.add(
|
||
kr_singBox.watchStatus().listen(
|
||
(status) {
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 收到 Native 状态更新: ${status.runtimeType}');
|
||
}
|
||
KRLogUtil.kr_i('📡 收到状态更新: $status', tag: 'SingBox');
|
||
kr_status.value = status;
|
||
// ✅ 系统代理由 Go 后端 (libcore.dll) 自动管理
|
||
// libcore 在 stop() 时会自动恢复系统代理，无需在 Dart 层处理
|
||
},
|
||
onError: (error) {
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 状态流错误: $error');
|
||
}
|
||
KRLogUtil.kr_e('📡 状态流错误: $error', tag: 'SingBox');
|
||
},
|
||
cancelOnError: false,
|
||
),
|
||
);
|
||
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 状态流订阅完成');
|
||
}
|
||
}
|
||
|
||
/// 订阅统计数据流
|
||
/// 🔧 UI阻塞修复：改为异步方法，在FFI调用前让出控制权
|
||
Future<void> _kr_subscribeToStats() async {
|
||
// 🔧 P0-1: 先取消旧的 stats 订阅
|
||
_subscriptionMap[_SubscriptionType.stats]?.cancel();
|
||
|
||
// 移除列表中的旧订阅（向后兼容）
|
||
for (var sub in _kr_subscriptions) {
|
||
if (sub.hashCode.toString().contains('Stats')) {
|
||
sub.cancel();
|
||
}
|
||
}
|
||
_kr_subscriptions
|
||
.removeWhere((sub) => sub.hashCode.toString().contains('Stats'));
|
||
|
||
// 🔧 关键修复：在调用同步FFI之前让出控制权，给UI一帧渲染时间
|
||
await Future.delayed(Duration.zero);
|
||
|
||
// ⚠️ 关键：watchStats() 内部会调用 FFI startCommandClient
|
||
// 如果此时 command.sock 未就绪，会抛出异常
|
||
// 所以外层必须有 try-catch
|
||
final stream = kr_singBox.watchStats();
|
||
final subscription = stream.listen(
|
||
(stats) {
|
||
kr_stats.value = stats;
|
||
},
|
||
onError: (error) {
|
||
KRLogUtil.kr_e('统计数据监听错误: $error', tag: 'SingBox');
|
||
},
|
||
cancelOnError: false,
|
||
);
|
||
|
||
// 🔧 P0-1: 使用 Map 精确管理订阅
|
||
_subscriptionMap[_SubscriptionType.stats] = subscription;
|
||
_kr_subscriptions.add(subscription);
|
||
|
||
KRLogUtil.kr_i('✅ Stats 订阅已建立', tag: 'SingBox');
|
||
}
|
||
|
||
/// 订阅分组数据流
|
||
/// 🔧 UI阻塞修复：改为异步方法，在FFI调用前让出控制权
|
||
Future<void> _kr_subscribeToGroups() async {
|
||
KRFileLogger.log('[黑屏调试] [_kr_subscribeToGroups] 🚀 开始订阅分组数据流');
|
||
|
||
// 🔧 P0-1: 先取消旧的 groups 订阅
|
||
_subscriptionMap[_SubscriptionType.groups]?.cancel();
|
||
|
||
// 移除列表中的旧订阅（向后兼容）
|
||
for (var sub in _kr_subscriptions) {
|
||
if (sub.hashCode.toString().contains('Groups')) {
|
||
sub.cancel();
|
||
}
|
||
}
|
||
_kr_subscriptions
|
||
.removeWhere((sub) => sub.hashCode.toString().contains('Groups'));
|
||
|
||
// 🔧 关键修复：在调用同步FFI之前让出控制权，给UI一帧渲染时间
|
||
await Future.delayed(Duration.zero);
|
||
|
||
// 订阅活动分组
|
||
final activeGroupsSubscription = kr_singBox.watchActiveGroups().listen(
|
||
(groups) {
|
||
KRFileLogger.log('[黑屏调试] [watchActiveGroups] 📡 收到活动组更新，数量: ${groups.length}');
|
||
KRLogUtil.kr_i('📡 收到活动组更新，数量: ${groups.length}', tag: 'SingBox');
|
||
kr_activeGroups.value = groups;
|
||
|
||
// 详细打印每个组的信息
|
||
for (int i = 0; i < groups.length; i++) {
|
||
final group = groups[i];
|
||
KRLogUtil.kr_i('📋 活动组[$i]: tag=${group.tag}, type=${group.type}, selected=${group.selected}', tag: 'SingBox');
|
||
for (int j = 0; j < group.items.length; j++) {
|
||
final item = group.items[j];
|
||
KRLogUtil.kr_i(' └─ 节点[$j]: tag=${item.tag}, type=${item.type}, delay=${item.urlTestDelay}', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ 活动组处理完成', tag: 'SingBox');
|
||
},
|
||
onError: (error) {
|
||
KRFileLogger.log('[黑屏调试] [watchActiveGroups] ❌ 活动分组监听错误: $error');
|
||
KRLogUtil.kr_e('❌ 活动分组监听错误: $error', tag: 'SingBox');
|
||
},
|
||
cancelOnError: false,
|
||
);
|
||
_kr_subscriptions.add(activeGroupsSubscription);
|
||
|
||
// 🔧 关键修复：在两个FFI调用之间让出控制权，避免连续阻塞UI
|
||
await Future.delayed(Duration.zero);
|
||
|
||
// 订阅所有分组
|
||
final allGroupsSubscription = kr_singBox.watchGroups().listen(
|
||
(groups) {
|
||
KRFileLogger.log('[黑屏调试] [watchGroups] 📡 收到所有组更新，数量: ${groups.length}');
|
||
kr_allGroups.value = groups;
|
||
// 打印每个组的基本信息
|
||
for (int i = 0; i < groups.length; i++) {
|
||
final group = groups[i];
|
||
KRFileLogger.log('[黑屏调试] [watchGroups] 组[$i]: tag=${group.tag}, type=${group.type}, selected=${group.selected}');
|
||
}
|
||
},
|
||
onError: (error) {
|
||
KRFileLogger.log('[黑屏调试] [watchGroups] ❌ 所有分组监听错误: $error');
|
||
KRLogUtil.kr_e('所有分组监听错误: $error');
|
||
},
|
||
cancelOnError: false,
|
||
);
|
||
_kr_subscriptions.add(allGroupsSubscription);
|
||
|
||
// 🔧 P0-1: 使用 Map 精确管理订阅（将两个都归为 'groups' 类型，因为它们共享生命周期）
|
||
_subscriptionMap[_SubscriptionType.groups] = activeGroupsSubscription;
|
||
|
||
KRFileLogger.log('[黑屏调试] [_kr_subscribeToGroups] ✅ 分组数据流订阅完成，当前订阅数: ${_kr_subscriptions.length}');
|
||
KRLogUtil.kr_i('✅ Groups 订阅已建立', tag: 'SingBox');
|
||
}
|
||
|
||
/// 带重试机制的节点选择
|
||
///
|
||
/// 确保 command.sock 准备好后再执行节点选择
|
||
Future<void> _kr_selectOutboundWithRetry(
|
||
String groupTag,
|
||
String outboundTag, {
|
||
int maxAttempts = 3,
|
||
int initialDelay = 100,
|
||
}) async {
|
||
int attempt = 0;
|
||
int delay = initialDelay;
|
||
|
||
while (attempt < maxAttempts) {
|
||
attempt++;
|
||
KRLogUtil.kr_i(
|
||
'🔄 尝试选择节点 $outboundTag (第 $attempt/$maxAttempts 次)',
|
||
tag: 'SingBox',
|
||
);
|
||
|
||
// 只在失败后才延迟，首次尝试立即执行
|
||
if (attempt > 1) {
|
||
await Future.delayed(Duration(milliseconds: delay));
|
||
}
|
||
|
||
try {
|
||
await kr_singBox.selectOutbound(groupTag, outboundTag).run();
|
||
KRLogUtil.kr_i('✅ 节点选择成功: $outboundTag', tag: 'SingBox');
|
||
return;
|
||
} catch (e) {
|
||
KRLogUtil.kr_w(
|
||
'⚠️ 第 $attempt 次节点选择失败: $e',
|
||
tag: 'SingBox',
|
||
);
|
||
|
||
if (attempt >= maxAttempts) {
|
||
KRLogUtil.kr_e(
|
||
'❌ 节点选择失败，已达到最大重试次数',
|
||
tag: 'SingBox',
|
||
);
|
||
throw Exception('节点选择失败: $e');
|
||
}
|
||
|
||
// 指数退避
|
||
delay = delay * 2;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 带重试机制的命令客户端初始化
|
||
///
|
||
/// command.sock 需要时间创建，因此需要重试机制
|
||
/// maxAttempts: 最大重试次数（默认10次，针对macOS优化）
|
||
/// initialDelay: 初始延迟毫秒数（默认1000ms，针对macOS优化）
|
||
Future<void> _kr_initializeCommandClientsWithRetry({
|
||
int maxAttempts = 10,
|
||
int initialDelay = 1000,
|
||
}) async {
|
||
int attempt = 0;
|
||
int delay = initialDelay;
|
||
|
||
while (attempt < maxAttempts) {
|
||
attempt++;
|
||
KRLogUtil.kr_i(
|
||
'🔄 尝试初始化命令客户端 (第 $attempt/$maxAttempts 次，延迟 ${delay}ms)',
|
||
tag: 'SingBox',
|
||
);
|
||
|
||
await Future.delayed(Duration(milliseconds: delay));
|
||
|
||
try {
|
||
// 先验证 command.sock 是否可访问
|
||
final socketFile = File(p.join(kr_configDics.baseDir.path, 'command.sock'));
|
||
KRLogUtil.kr_i('🔍 检查 socket 文件: ${socketFile.path}', tag: 'SingBox');
|
||
|
||
if (!socketFile.existsSync()) {
|
||
throw Exception('command.sock 文件不存在: ${socketFile.path}');
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ socket 文件存在，开始订阅...', tag: 'SingBox');
|
||
|
||
// 尝试订阅统计和分组数据
|
||
// ⚠️ 关键：分别 try-catch，避免一个失败影响另一个
|
||
bool statsSubscribed = false;
|
||
bool groupsSubscribed = false;
|
||
|
||
// 🔧 UI阻塞修复：订阅方法现在是异步的，会在FFI调用前让出控制权
|
||
try {
|
||
KRLogUtil.kr_i('📊 订阅统计数据流...', tag: 'SingBox');
|
||
await _kr_subscribeToStats(); // 🔧 修复：使用await调用异步方法
|
||
statsSubscribed = true;
|
||
KRLogUtil.kr_i('✅ 统计数据流订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 统计数据流订阅失败: $e', tag: 'SingBox');
|
||
}
|
||
|
||
try {
|
||
KRLogUtil.kr_i('📋 订阅分组数据流...', tag: 'SingBox');
|
||
await _kr_subscribeToGroups(); // 🔧 修复：使用await调用异步方法
|
||
groupsSubscribed = true;
|
||
KRLogUtil.kr_i('✅ 分组数据流订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 分组数据流订阅失败: $e', tag: 'SingBox');
|
||
}
|
||
|
||
// 至少有一个订阅成功才算初始化成功
|
||
if (!statsSubscribed && !groupsSubscribed) {
|
||
throw Exception('所有订阅都失败了');
|
||
}
|
||
|
||
// 等待更长时间验证订阅是否成功，并实际接收到数据
|
||
KRLogUtil.kr_i('⏳ 等待800ms验证订阅状态...', tag: 'SingBox');
|
||
await Future.delayed(const Duration(milliseconds: 800));
|
||
|
||
// 验证订阅是否真正工作（检查是否有数据流）
|
||
if (_kr_subscriptions.isEmpty) {
|
||
throw Exception('订阅列表为空，command client 未成功连接');
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ 命令客户端初始化成功，活跃订阅数: ${_kr_subscriptions.length}', tag: 'SingBox');
|
||
return;
|
||
} catch (e, stackTrace) {
|
||
// 详细记录失败原因和堆栈信息
|
||
KRLogUtil.kr_w(
|
||
'⚠️ 第 $attempt 次尝试失败',
|
||
tag: 'SingBox',
|
||
);
|
||
KRLogUtil.kr_w('❌ 错误类型: ${e.runtimeType}', tag: 'SingBox');
|
||
KRLogUtil.kr_w('❌ 错误信息: $e', tag: 'SingBox');
|
||
KRLogUtil.kr_w('📚 错误堆栈: $stackTrace', tag: 'SingBox');
|
||
|
||
if (attempt >= maxAttempts) {
|
||
KRLogUtil.kr_e(
|
||
'❌ 命令客户端初始化失败，已达到最大重试次数 ($maxAttempts)',
|
||
tag: 'SingBox',
|
||
);
|
||
KRLogUtil.kr_e('💡 提示: command.sock 可能未准备好或权限不足', tag: 'SingBox');
|
||
throw Exception('命令客户端初始化失败: $e');
|
||
}
|
||
|
||
// 指数退避：每次失败后延迟翻倍（1000ms -> 2000ms -> 4000ms -> 8000ms）
|
||
delay = delay * 2;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 在后台尝试预连接 command client（不阻塞启动流程）
|
||
///
|
||
/// 借鉴 Hiddify 的设计思想：
|
||
/// - watchStats/watchGroups 是懒加载的，首次调用时才会 startCommandClient()
|
||
/// - 但我们可以在后台提前尝试连接，提高成功率
|
||
/// - 即使失败也不影响主流程，真正的订阅会在 UI 调用时发生
|
||
void _kr_tryPreconnectCommandClientsInBackground() {
|
||
KRLogUtil.kr_i('🔄 后台启动 command client 预连接任务...', tag: 'SingBox');
|
||
|
||
// 使用 Future.microtask 确保不阻塞当前执行
|
||
Future.microtask(() async {
|
||
try {
|
||
// 等待 command.sock 就绪（macOS 需要更长时间）
|
||
await Future.delayed(const Duration(milliseconds: 1500));
|
||
|
||
// 检查 socket 文件
|
||
final socketFile = File(p.join(kr_configDics.baseDir.path, 'command.sock'));
|
||
if (!socketFile.existsSync()) {
|
||
KRLogUtil.kr_w('⚠️ command.sock 尚未创建，预连接取消', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ command.sock 已就绪，尝试预订阅...', tag: 'SingBox');
|
||
|
||
// 🔧 UI阻塞修复：订阅方法现在是异步的，会在FFI调用前让出控制权
|
||
// 如果失败，UI 调用时会重新尝试
|
||
try {
|
||
await _kr_subscribeToStats(); // 🔧 修复：使用await
|
||
KRLogUtil.kr_i('✅ 统计流预订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 统计流预订阅失败（正常，UI 调用时会重试）: $e', tag: 'SingBox');
|
||
}
|
||
|
||
try {
|
||
await _kr_subscribeToGroups(); // 🔧 修复：使用await
|
||
KRLogUtil.kr_i('✅ 分组流预订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 分组流预订阅失败（正常，UI 调用时会重试）: $e', tag: 'SingBox');
|
||
}
|
||
|
||
} catch (e) {
|
||
// 静默失败，不影响主流程
|
||
KRLogUtil.kr_w('⚠️ 后台预连接任务失败（不影响正常使用）: $e', tag: 'SingBox');
|
||
}
|
||
});
|
||
}
|
||
|
||
/// 确保 command client 已初始化（通过触发订阅来初始化）
|
||
///
|
||
/// 借鉴 Hiddify:watchGroups() 会在首次调用时自动 startCommandClient()
|
||
Future<void> _kr_ensureCommandClientInitialized() async {
|
||
// 🔧 P0-1 + P2新: 改进订阅检查 - 检查是否真正有 groups 和 stats 订阅
|
||
// 而不是仅检查列表是否非空（Status 订阅也会在列表中，容易误判）
|
||
final hasGroupsSubscription = _subscriptionMap[_SubscriptionType.groups] != null;
|
||
final hasStatsSubscription = _subscriptionMap[_SubscriptionType.stats] != null;
|
||
|
||
if (hasGroupsSubscription && hasStatsSubscription) {
|
||
KRLogUtil.kr_i('✅ Command client 已初始化（groups: ✓, stats: ✓）', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
KRLogUtil.kr_i('⚠️ Command client 未初始化或订阅丢失，重新初始化...', tag: 'SingBox');
|
||
|
||
// 🔧 P1-3: 使用 Mutex 保护初始化过程，防止并发调用导致重复初始化（内存泄漏）
|
||
await _commandClientInitLock.synchronized(() async {
|
||
try {
|
||
// 再次检查（double-check locking 模式，避免在等待锁期间被其他线程初始化）
|
||
final hasGroupsSubscription = _subscriptionMap[_SubscriptionType.groups] != null;
|
||
final hasStatsSubscription = _subscriptionMap[_SubscriptionType.stats] != null;
|
||
|
||
if (hasGroupsSubscription && hasStatsSubscription) {
|
||
KRLogUtil.kr_i('✅ Command client 在等待期间已被初始化，跳过重复初始化', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
// 🔧 UI阻塞修复：订阅方法现在是异步的，会在FFI调用前让出控制权
|
||
await _kr_subscribeToGroups(); // 🔧 修复：使用await
|
||
await _kr_subscribeToStats(); // 🔧 修复：使用await
|
||
|
||
// 等待订阅建立完成
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
|
||
// 验证订阅是否真的建立了
|
||
if (_subscriptionMap[_SubscriptionType.groups] == null ||
|
||
_subscriptionMap[_SubscriptionType.stats] == null) {
|
||
throw Exception('订阅失败，command client 未初始化');
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ Command client 初始化成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ Command client 初始化失败: $e', tag: 'SingBox');
|
||
rethrow;
|
||
}
|
||
});
|
||
}
|
||
|
||
/// 在后台恢复用户保存的节点选择（不阻塞启动流程）
|
||
///
|
||
/// selectOutbound() 依赖 command client，必须延迟执行
|
||
void _kr_restoreSavedNodeInBackground() {
|
||
KRLogUtil.kr_i('🔄 启动节点恢复后台任务...', tag: 'SingBox');
|
||
|
||
Future.microtask(() async {
|
||
try {
|
||
// 等待 command client 初始化
|
||
await Future.delayed(const Duration(milliseconds: 2000));
|
||
|
||
final savedNode = await KRSecureStorage().kr_readData(key: _keySelectedNode);
|
||
if (savedNode != null && savedNode.isNotEmpty && savedNode != 'auto') {
|
||
KRLogUtil.kr_i('🔄 恢复用户选择的节点: $savedNode', tag: 'SingBox');
|
||
|
||
try {
|
||
await _kr_selectOutboundWithRetry("select", savedNode);
|
||
KRLogUtil.kr_i('✅ 节点恢复完成', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 节点恢复失败（可能 command client 未就绪）: $e', tag: 'SingBox');
|
||
}
|
||
} else {
|
||
KRLogUtil.kr_i('ℹ️ 使用默认节点选择 (auto)', tag: 'SingBox');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 节点恢复后台任务失败: $e', tag: 'SingBox');
|
||
}
|
||
});
|
||
}
|
||
|
||
/// 监听活动组的详细实现
|
||
// Future<void> watchActiveGroups() async {
|
||
// try {
|
||
// print("开始监听活动组详情...");
|
||
|
||
// final status = await kr_singBox.status();
|
||
// print("服务状态: ${status.toJson()}");
|
||
|
||
// final outbounds = await kr_singBox.listOutbounds();
|
||
// print("出站列表: ${outbounds.toJson()}");
|
||
|
||
// for (var outbound in outbounds.outbounds) {
|
||
// print("出站配置: ${outbound.toJson()}");
|
||
|
||
// // 检查出站是否活动
|
||
// final isActive = await kr_singBox.isOutboundActive(outbound.tag);
|
||
// print("出站 ${outbound.tag} 活动状态: $isActive");
|
||
// }
|
||
// } catch (e, stack) {
|
||
// print("监听活动组详情时出错: $e");
|
||
// print("错误堆栈: $stack");
|
||
// }
|
||
// }
|
||
|
||
/// 保存配置文件
|
||
void kr_saveOutbounds(List<Map<String, dynamic>> outbounds) async {
|
||
KRLogUtil.kr_i('💾 开始保存配置文件...', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📊 出站节点数量: ${outbounds.length}', tag: 'SingBox');
|
||
|
||
// 打印每个节点的详细配置
|
||
for (int i = 0; i < outbounds.length; i++) {
|
||
final outbound = outbounds[i];
|
||
KRLogUtil.kr_i('📋 节点[$i] 配置:', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - type: ${outbound['type']}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - tag: ${outbound['tag']}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - server: ${outbound['server']}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - server_port: ${outbound['server_port']}', tag: 'SingBox');
|
||
if (outbound['method'] != null) {
|
||
KRLogUtil.kr_i(' - method: ${outbound['method']}', tag: 'SingBox');
|
||
}
|
||
if (outbound['password'] != null) {
|
||
KRLogUtil.kr_i(' - password: ${outbound['password']?.toString().substring(0, 8)}...', tag: 'SingBox');
|
||
}
|
||
if (outbound['uuid'] != null) {
|
||
KRLogUtil.kr_i(' - uuid: ${outbound['uuid']?.toString().substring(0, 8)}...', tag: 'SingBox');
|
||
}
|
||
KRLogUtil.kr_i(' - 完整配置: ${jsonEncode(outbound)}', tag: 'SingBox');
|
||
}
|
||
|
||
// ⚠️ 临时过滤 Hysteria2 节点以避免 libcore 崩溃
|
||
kr_outbounds = outbounds.where((outbound) {
|
||
final type = outbound['type'];
|
||
if (type == 'hysteria2' || type == 'hysteria') {
|
||
KRLogUtil.kr_w('⚠️ 跳过 Hysteria2 节点: ${outbound['tag']} (libcore bug)', tag: 'SingBox');
|
||
return false;
|
||
}
|
||
return true;
|
||
}).toList();
|
||
|
||
KRLogUtil.kr_i('✅ 过滤后节点数量: ${kr_outbounds.length}/${outbounds.length}', tag: 'SingBox');
|
||
|
||
// Use hiddify-app flow: save only base outbounds.
|
||
// libcore builds full config from HiddifyOptions.
|
||
final Map<String, dynamic> baseConfig = {
|
||
"outbounds": [
|
||
if (kr_outbounds.isNotEmpty)
|
||
{
|
||
"type": "selector",
|
||
"tag": "proxy",
|
||
"outbounds": kr_outbounds.map((o) => o['tag'] as String).toList(),
|
||
"default": kr_outbounds[0]['tag'],
|
||
},
|
||
...kr_outbounds,
|
||
],
|
||
};
|
||
|
||
final file = _file(kr_configName);
|
||
final temp = _tempFile(kr_configName);
|
||
final mapStr = jsonEncode(baseConfig);
|
||
|
||
KRLogUtil.kr_i('Config length: ${mapStr.length}', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📄 Outbounds 数量: ${kr_outbounds.length}', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📄 配置前800字符:\n${mapStr.substring(0, mapStr.length > 800 ? 800 : mapStr.length)}', tag: 'SingBox');
|
||
|
||
await file.writeAsString(mapStr);
|
||
await temp.writeAsString(mapStr);
|
||
|
||
_cutPath = file.path;
|
||
KRLogUtil.kr_i('📁 配置文件路径: $_cutPath', tag: 'SingBox');
|
||
|
||
// Align with hiddify-app: send HiddifyOptions before validate.
|
||
final oOption = SingboxConfigOption.fromJson(_getConfigOption());
|
||
await kr_singBox.changeOptions(oOption).mapLeft((err) {
|
||
KRLogUtil.kr_e('Config changeOptions failed before validate: $err', tag: 'SingBox');
|
||
}).run();
|
||
|
||
await kr_singBox
|
||
.validateConfigByPath(file.path, temp.path, false)
|
||
.mapLeft((err) {
|
||
KRLogUtil.kr_e('❌ 保存配置文件失败: $err', tag: 'SingBox');
|
||
}).run();
|
||
|
||
KRLogUtil.kr_i('✅ 配置文件保存完成', tag: 'SingBox');
|
||
}
|
||
|
||
/// 构建 DNS 规则
|
||
List<Map<String, dynamic>> _kr_buildDnsRules() {
|
||
final currentCountryCode = KRCountryUtil.kr_getCurrentCountryCode();
|
||
final rules = <Map<String, dynamic>>[];
|
||
|
||
// 🔧 关键修复：只有在"智能代理"模式下，才根据国家添加直连规则
|
||
// 如果是"全局代理"模式，即使选择了国家也不添加直连规则
|
||
if (kr_connectionType.value == KRConnectionType.rule && currentCountryCode != 'other') {
|
||
rules.add({
|
||
"rule_set": [
|
||
"geoip-$currentCountryCode",
|
||
"geosite-$currentCountryCode",
|
||
],
|
||
"server": "dns-direct"
|
||
});
|
||
|
||
KRLogUtil.kr_i('✅ [智能代理模式] 添加 DNS 规则: $currentCountryCode 域名使用直连 DNS', tag: 'SingBox');
|
||
} else if (kr_connectionType.value == KRConnectionType.global) {
|
||
KRLogUtil.kr_i('🌐 [全局代理模式] 跳过国家 DNS 规则，所有DNS查询走代理', tag: 'SingBox');
|
||
}
|
||
|
||
return rules;
|
||
}
|
||
|
||
/// 构建路由规则
|
||
List<Map<String, dynamic>> _kr_buildRouteRules() {
|
||
final currentCountryCode = KRCountryUtil.kr_getCurrentCountryCode();
|
||
final rules = <Map<String, dynamic>>[];
|
||
|
||
// 基础规则: DNS 查询走 dns-out
|
||
rules.add({
|
||
"protocol": "dns",
|
||
"outbound": "dns-out"
|
||
});
|
||
|
||
// 🔧 关键修复：只有在"智能代理"模式下，才根据国家添加直连规则
|
||
// 如果是"全局代理"模式，即使选择了国家也不添加直连规则
|
||
if (kr_connectionType.value == KRConnectionType.rule && currentCountryCode != 'other') {
|
||
rules.add({
|
||
"rule_set": [
|
||
"geoip-$currentCountryCode",
|
||
"geosite-$currentCountryCode",
|
||
],
|
||
"outbound": "direct"
|
||
});
|
||
|
||
KRLogUtil.kr_i('✅ [智能代理模式] 添加路由规则: $currentCountryCode IP/域名直连', tag: 'SingBox');
|
||
} else if (kr_connectionType.value == KRConnectionType.global) {
|
||
KRLogUtil.kr_i('🌐 [全局代理模式] 跳过国家路由规则，所有流量走代理', tag: 'SingBox');
|
||
}
|
||
|
||
return rules;
|
||
}
|
||
|
||
/// 构建规则集配置
|
||
List<Map<String, dynamic>> _kr_buildRuleSets() {
|
||
final currentCountryCode = KRCountryUtil.kr_getCurrentCountryCode();
|
||
final ruleSets = <Map<String, dynamic>>[];
|
||
|
||
// 🔧 关键修复：只有在"智能代理"模式下，才加载国家规则集
|
||
// 如果是"全局代理"模式，即使选择了国家也不加载规则集
|
||
if (kr_connectionType.value == KRConnectionType.rule && currentCountryCode != 'other') {
|
||
// 检查本地文件是否存在
|
||
final geoipFile = File(p.join(kr_configDics.workingDir.path, 'geosite', 'geoip-$currentCountryCode.srs'));
|
||
final geositeFile = File(p.join(kr_configDics.workingDir.path, 'geosite', 'geosite-$currentCountryCode.srs'));
|
||
|
||
if (geoipFile.existsSync() && geositeFile.existsSync()) {
|
||
// ✅ 使用本地文件
|
||
ruleSets.add({
|
||
"type": "local",
|
||
"tag": "geoip-$currentCountryCode",
|
||
"format": "binary",
|
||
"path": "./geosite/geoip-$currentCountryCode.srs" // 相对于 workingDir
|
||
});
|
||
|
||
ruleSets.add({
|
||
"type": "local",
|
||
"tag": "geosite-$currentCountryCode",
|
||
"format": "binary",
|
||
"path": "./geosite/geosite-$currentCountryCode.srs"
|
||
});
|
||
|
||
KRLogUtil.kr_i('✅ 使用本地规则集: $currentCountryCode', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - geoip: ./geosite/geoip-$currentCountryCode.srs', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - geosite: ./geosite/geosite-$currentCountryCode.srs', tag: 'SingBox');
|
||
} else {
|
||
// ❌ 本地文件不存在,使用远程规则集作为后备
|
||
KRLogUtil.kr_w('⚠️ 本地规则集不存在,使用远程规则集', tag: 'SingBox');
|
||
KRLogUtil.kr_w(' - geoip 文件存在: ${geoipFile.existsSync()}', tag: 'SingBox');
|
||
KRLogUtil.kr_w(' - geosite 文件存在: ${geositeFile.existsSync()}', tag: 'SingBox');
|
||
|
||
ruleSets.add({
|
||
"type": "remote",
|
||
"tag": "geoip-$currentCountryCode",
|
||
"format": "binary",
|
||
"url": "https://raw.githubusercontent.com/hiddify/hiddify-geo/rule-set/country/geoip-$currentCountryCode.srs",
|
||
"download_detour": "direct",
|
||
"update_interval": "7d"
|
||
});
|
||
|
||
ruleSets.add({
|
||
"type": "remote",
|
||
"tag": "geosite-$currentCountryCode",
|
||
"format": "binary",
|
||
"url": "https://raw.githubusercontent.com/hiddify/hiddify-geo/rule-set/country/geosite-$currentCountryCode.srs",
|
||
"download_detour": "direct",
|
||
"update_interval": "7d"
|
||
});
|
||
}
|
||
}
|
||
|
||
return ruleSets;
|
||
}
|
||
|
||
Future<void> kr_start() async {
|
||
// 🔧 文件日志：记录 kr_start() 调用 + 时间戳
|
||
final clickTime = DateTime.now();
|
||
await KRFileLogger.log('[黑屏调试] [DEBUG-START] kr_start() 方法被调用 - $clickTime');
|
||
await KRFileLogger.log('[kr_start] ⏱️ 用户点击启动 VPN - $clickTime');
|
||
|
||
// 🔧 P0-3: 防止重复启动，避免备份被覆盖
|
||
if (kr_status.value is SingboxStarted) {
|
||
KRLogUtil.kr_w('⚠️ VPN 已在运行，请勿重复启动', tag: 'SingBox');
|
||
await KRFileLogger.log('[kr_start] VPN 已在运行，返回');
|
||
await KRFileLogger.log('[黑屏调试] [DEBUG-START] VPN 已在运行，直接返回');
|
||
return;
|
||
}
|
||
|
||
// 🔧 文件日志：等待 Lock + 时间戳
|
||
final beforeLock = DateTime.now();
|
||
await KRFileLogger.log('[黑屏调试] [DEBUG-START] 准备等待 Lock - $beforeLock');
|
||
await KRFileLogger.log('[kr_start] ⏱️ 开始等待 Lock... - $beforeLock');
|
||
await KRFileLogger.log('[黑屏调试] [DEBUG-START] 已打印等待 Lock 日志 - ${DateTime.now()}');
|
||
|
||
// 🔧 VPN 开关防卡顿：使用 Mutex 确保 kr_start() 和 kr_stop() 不会并发执行
|
||
// 快速连续点击 VPN 开关时，此 Lock 会序列化所有操作，防止系统过载
|
||
return _startStopLock.synchronized(() async {
|
||
final afterLock = DateTime.now();
|
||
final lockWaitMs = afterLock.difference(beforeLock).inMilliseconds;
|
||
|
||
// 🔍 诊断：Lock 等待时间检查
|
||
if (lockWaitMs > 1000) {
|
||
await KRFileLogger.log('[kr_start] 🚨 【关键诊断】Lock 等待超过 1000ms（等待 ${lockWaitMs}ms）！');
|
||
await KRFileLogger.log('[kr_start] 🚨 这说明前一个操作（kr_stop）还没释放 Lock，可能被后台任务阻塞！');
|
||
await KRFileLogger.log('[kr_start] 🚨 可能原因：后台 DNS/代理恢复或者后台订阅任务被阻塞');
|
||
} else {
|
||
await KRFileLogger.log('[kr_start] ✅ Lock 已获取（等待 ${lockWaitMs}ms，正常）');
|
||
}
|
||
await KRFileLogger.log('[kr_start] ✅ Lock 已获取（等待 ${lockWaitMs}ms）- $afterLock');
|
||
|
||
try {
|
||
final beforeInternal = DateTime.now();
|
||
await _kr_startInternal();
|
||
final afterInternal = DateTime.now();
|
||
final internalMs = afterInternal.difference(beforeInternal).inMilliseconds;
|
||
await KRFileLogger.log('[kr_start] ✅ _kr_startInternal() 完成（耗时 ${internalMs}ms）- $afterInternal');
|
||
} catch (e) {
|
||
await KRFileLogger.log('[kr_start] ❌ _kr_startInternal() 异常: $e - ${DateTime.now()}');
|
||
rethrow;
|
||
}
|
||
});
|
||
}
|
||
|
||
/// 实际的启动逻辑（被 Lock 保护）
|
||
Future<void> _kr_startInternal() async {
|
||
// ✅ DNS 由 libcore.dll 自动管理
|
||
// 再次检查状态（Lock 内部二次检查）
|
||
if (kr_status.value is SingboxStarted) {
|
||
KRLogUtil.kr_i('✅ VPN 已在运行（Lock 内检查）', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
// 不再手动设置状态，libcore 会通过 status stream 自动发送状态更新
|
||
try {
|
||
// 🔧 修复3: 添加登录状态检查 - 只有已登录用户才能连接VPN
|
||
if (!KRAppRunData().kr_isLogin.value) {
|
||
KRLogUtil.kr_e('❌ 未登录用户，禁止启动VPN连接', tag: 'SingBox');
|
||
throw Exception('用户未登录，无法启动VPN服务');
|
||
}
|
||
|
||
// ✅ 改进：应用启动时已由 manifest 要求管理员权限（UAC 提升）
|
||
// 用户同意 UAC 提示后，应用以管理员身份运行，可以直接使用 TUN 模式
|
||
// 无需在运行时再做权限检查
|
||
if (Platform.isWindows && kr_connectionType.value == KRConnectionType.global) {
|
||
KRLogUtil.kr_i('✅ 应用已以管理员身份运行，可以使用全局代理模式（TUN）', tag: 'SingBox');
|
||
}
|
||
|
||
// 🪟 Windows 预检查：避免 command server 固定端口 8964 被占用导致启动失败
|
||
// ⚠️ 强制编译标记 - v2.0-lazy-load
|
||
KRLogUtil.kr_i('🚀🚀🚀 [v2.0-lazy-load] 开始启动 SingBox...', tag: 'SingBox');
|
||
|
||
// 🔧 强制重新生成配置文件（确保最新的路由规则生效）
|
||
if (kr_outbounds.isNotEmpty) {
|
||
KRLogUtil.kr_i('🔄 启动前强制重新生成配置文件...', tag: 'SingBox');
|
||
kr_saveOutbounds(kr_outbounds);
|
||
// 等待配置文件写入完成
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
}
|
||
|
||
KRLogUtil.kr_i('📁 配置文件路径: $_cutPath', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📝 配置名称: $kr_configName', tag: 'SingBox');
|
||
|
||
// ✅ DNS 由 sing-box 内部代理机制处理，不需要手动备份/恢复
|
||
// 参考 Hiddify 实现：sing-box 有 local-dns-port、remote-dns-address 等 DNS 配置
|
||
|
||
// 🔑 先尝试停止旧实例，避免 command.sock 冲突
|
||
// 注意：如果没有旧实例，libcore 会报错 "command.sock: no such file"，这是正常的
|
||
try {
|
||
await KRFileLogger.log('[_kr_startInternal] 开始停止旧实例 - ${DateTime.now()}');
|
||
await kr_singBox.stop().run();
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
KRLogUtil.kr_i('✅ 已清理旧实例', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_startInternal] 旧实例已停止 - ${DateTime.now()}');
|
||
} catch (e) {
|
||
// 预期行为：没有旧实例时会报错，可以忽略
|
||
KRLogUtil.kr_i('ℹ️ 没有运行中的旧实例（正常）', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_startInternal] 旧实例不存在（正常）- ${DateTime.now()}');
|
||
}
|
||
|
||
// 🔑 关键步骤：在 start 之前必须调用 changeOptions 初始化 HiddifyOptions
|
||
// 否则 libcore 的 StartService 会因为 HiddifyOptions == nil 而 panic
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ▶️ 步骤1: 准备 changeOptions...');
|
||
KRLogUtil.kr_i('📡 初始化 HiddifyOptions...', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_startInternal] 开始 changeOptions - ${DateTime.now()}');
|
||
await _kr_preflightWindowsCommandServerPort();
|
||
final configMap = _getConfigOption();
|
||
final oOption = SingboxConfigOption.fromJson(configMap);
|
||
|
||
// ✅ 调试日志：确认 setSystemProxy 值正确传递给 libcore.dll
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] 📦 set-system-proxy: ${configMap["set-system-proxy"]}');
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] 📦 enable-tun: ${configMap["enable-tun"]}');
|
||
KRLogUtil.kr_i('📡 HiddifyOptions 关键配置:', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - set-system-proxy: ${configMap["set-system-proxy"]}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - enable-tun: ${configMap["enable-tun"]}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - mixed-port: ${configMap["mixed-port"]}', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_startInternal] HiddifyOptions: set-system-proxy=${configMap["set-system-proxy"]}, enable-tun=${configMap["enable-tun"]}, mixed-port=${configMap["mixed-port"]}');
|
||
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ⏳ 步骤2: 调用 changeOptions (libcore.dll)...');
|
||
final changeOptionsStartTime = DateTime.now();
|
||
final changeResult = await kr_singBox.changeOptions(oOption).run();
|
||
final changeOptionsDuration = DateTime.now().difference(changeOptionsStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ✅ 步骤2完成: changeOptions 耗时 ${changeOptionsDuration}ms');
|
||
await KRFileLogger.log('[_kr_startInternal] changeOptions 完成 - ${DateTime.now()}');
|
||
changeResult.match(
|
||
(error) {
|
||
KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ❌ changeOptions 失败: $error');
|
||
KRLogUtil.kr_e('❌ changeOptions() 失败: $error', tag: 'SingBox');
|
||
throw Exception('初始化 HiddifyOptions 失败: $error');
|
||
},
|
||
(_) {
|
||
KRLogUtil.kr_i('✅ HiddifyOptions 初始化成功', tag: 'SingBox');
|
||
},
|
||
);
|
||
|
||
// 检查配置文件是否存在
|
||
final configFile = File(_cutPath);
|
||
if (await configFile.exists()) {
|
||
final configContent = await configFile.readAsString();
|
||
KRLogUtil.kr_i('📄 配置文件内容长度: ${configContent.length}', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📄 配置文件前500字符: ${configContent.substring(0, configContent.length > 500 ? 500 : configContent.length)}', tag: 'SingBox');
|
||
} else {
|
||
KRLogUtil.kr_w('⚠️ 配置文件不存在: $_cutPath', tag: 'SingBox');
|
||
}
|
||
|
||
// 🔧 修复: 在启动前重新订阅状态流，确保能收到状态更新
|
||
_kr_subscribeToStatus();
|
||
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ⏳ 步骤3: 调用 start (libcore.dll)...');
|
||
final startStartTime = DateTime.now();
|
||
await KRFileLogger.log('[_kr_startInternal] 🔴 开始 kr_singBox.start() - $startStartTime');
|
||
await kr_singBox.start(_cutPath, kr_configName, false).map(
|
||
(r) {
|
||
KRLogUtil.kr_i('✅ SingBox 启动成功', tag: 'SingBox');
|
||
},
|
||
).mapLeft((err) {
|
||
KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ❌ start 失败: $err');
|
||
KRLogUtil.kr_e('❌ SingBox 启动失败: $err', tag: 'SingBox');
|
||
// 不需要手动设置状态，libcore 会通过 status stream 自动发送 Stopped 事件
|
||
throw err;
|
||
}).run();
|
||
|
||
final startEndTime = DateTime.now();
|
||
final startDurationMs = startEndTime.difference(startStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ✅ 步骤3完成: start 耗时 ${startDurationMs}ms');
|
||
await KRFileLogger.log('[_kr_startInternal] ✅ kr_singBox.start() 完成（耗时: ${startDurationMs}ms）- $startEndTime');
|
||
|
||
// 🔍 关键诊断：检查 8964 端口是否真的准备好了！
|
||
await KRFileLogger.log('[_kr_startInternal] 🔍 检查 sing-box 的 8964 端口是否真的准备好...');
|
||
bool port8964Ready = false;
|
||
int connectionAttempts = 0;
|
||
final portCheckStartTime = DateTime.now();
|
||
|
||
// 立即尝试连接，看 sing-box 是否真的启动了
|
||
try {
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 500),
|
||
onTimeout: () => throw Exception('8964 端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
port8964Ready = true;
|
||
connectionAttempts = 0;
|
||
await KRFileLogger.log('[_kr_startInternal] ✅ 8964 端口已准备好（立即连接成功）');
|
||
} catch (e) {
|
||
// 立即失败，说明 sing-box 还没准备好
|
||
connectionAttempts = 1;
|
||
final portCheckDuration = DateTime.now().difference(portCheckStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[_kr_startInternal] ❌ 【关键发现】8964 端口未准备好！（连接失败：$e）');
|
||
await KRFileLogger.log('[_kr_startInternal] 🚨 这说明 start() 返回成功，但 sing-box 还在初始化中！');
|
||
await KRFileLogger.log('[_kr_startInternal] 🚨 后台任务在 1000ms 后会尝试订阅，极可能失败（这是 UI 卡顿的根本原因！）');
|
||
}
|
||
|
||
// ✅ 系统代理由 Go 后端 (libcore.dll) 自动处理
|
||
// 原因：通过 changeOptions() 传递 setSystemProxy: true，libcore 会自动设置系统代理
|
||
// 参考 Hiddify 实现：Dart 层不再手动调用注册表或 WinINet API
|
||
await KRFileLogger.log('[_kr_startInternal] ℹ️ 系统代理由 libcore 自动管理 - ${DateTime.now()}');
|
||
|
||
// 🍎 macOS 专用：额外设置 SOCKS5 系统代理（让 Telegram 等应用自动走代理）
|
||
// 原因：libcore 只设置 HTTP/HTTPS 代理，但 Telegram 只检测 SOCKS5 代理
|
||
// 参考 Clash：同时设置 HTTP + SOCKS5 系统代理
|
||
if (Platform.isMacOS && kr_connectionType.value != KRConnectionType.global) {
|
||
await _kr_setMacOSSocks5Proxy(true);
|
||
}
|
||
|
||
// 🔴 【方案 A】启动 sing-box 进程健康监测
|
||
// 目的：检测 sing-box 是否在启动后 1-2 秒内崩溃
|
||
// 背景：日志显示 start() 返回成功，但 1.4 秒后 8964 端口无法连接
|
||
// 说明 sing-box 进程启动后崩溃了，导致后续 UI 卡顿
|
||
unawaited(_monitorSingBoxProcess());
|
||
|
||
// ⚠️ 关键修复：在启动成功后立即订阅统计流
|
||
// 原因：
|
||
// 1. 统计流需要主动订阅才能接收数据
|
||
// 2. UI 只是读取 kr_stats.value，不会触发订阅
|
||
// 3. command.sock 在 start() 成功后会立即创建
|
||
|
||
KRLogUtil.kr_i('✅ SingBox 核心已启动，开始初始化 command client', tag: 'SingBox');
|
||
|
||
// 🔑 在后台延迟订阅统计流和分组流，避免阻塞 UI
|
||
await KRFileLogger.log('[_kr_startInternal] 🟢 关键路径完成，返回给调用者 - ${DateTime.now()}');
|
||
Future.delayed(const Duration(milliseconds: 1000), () async {
|
||
final backgroundStartTime = DateTime.now();
|
||
|
||
// 【关键】检查停止标志，如果用户在延迟期间点击了停止，就立即返回
|
||
// 这避免了竞态条件：后台任务在 stop() 过程中仍然在执行订阅
|
||
if (_stopRequested) {
|
||
await KRFileLogger.log('[后台任务] ⏭️ 检测到停止标志，后台任务立即返回（避免竞态条件） - $backgroundStartTime');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
await KRFileLogger.log('[后台任务] 🔴 启动 1000ms 延迟后的后台任务 - $backgroundStartTime');
|
||
|
||
// 订阅统计流
|
||
try {
|
||
// 🔍 诊断：检查 8964 端口状态
|
||
final subscribeCheckStartTime = DateTime.now();
|
||
bool port8964ConnectOk = false;
|
||
try {
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 200),
|
||
onTimeout: () => throw Exception('端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
port8964ConnectOk = true;
|
||
await KRFileLogger.log('[后台任务] 📊 准备订阅前检查：8964 端口✅可以连接');
|
||
} catch (portE) {
|
||
await KRFileLogger.log('[后台任务] 📊 准备订阅前检查：8964 端口❌无法连接（$portE）- 这说明 sing-box 还没准备好！');
|
||
}
|
||
|
||
// 🔧 关键修复：如果端口检查失败，立即返回，避免 FFI 调用阻塞 UI 3+ 秒
|
||
if (!port8964ConnectOk) {
|
||
await KRFileLogger.log('[后台任务] ⛔ 8964 端口不可用，跳过订阅操作（避免 FFI 超时阻塞 UI）- ${DateTime.now()}');
|
||
KRLogUtil.kr_w('⚠️ sing-box command 端口不可用，跳过订阅', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
// 【关键】在执行订阅前再次检查停止标志
|
||
if (_stopRequested) {
|
||
await KRFileLogger.log('[后台任务] ⏭️ 停止标志已设置，取消统计订阅 - ${DateTime.now()}');
|
||
return;
|
||
}
|
||
|
||
await KRFileLogger.log('[后台任务] 🟡 开始订阅统计数据流 - ${DateTime.now()}');
|
||
KRLogUtil.kr_i('📊 开始订阅统计数据流...', tag: 'SingBox');
|
||
await _kr_subscribeToStats(); // 🔧 UI阻塞修复：使用await确保让出控制权
|
||
KRLogUtil.kr_i('✅ 统计数据流订阅成功', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ✅ 统计数据流订阅成功 - ${DateTime.now()}');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 统计数据流订阅失败（稍后重试）: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ❌ 统计数据流订阅失败: $e - ${DateTime.now()}');
|
||
await KRFileLogger.log('[后台任务] 🚨 这是导致后续操作失败的关键问题！后台任务被阻塞，导致 Lock 被占用！');
|
||
// 如果第一次失败，再等待一段时间重试
|
||
Future.delayed(const Duration(milliseconds: 2000), () async {
|
||
// 🔧 重试前检查端口可用性，避免 FFI 阻塞
|
||
try {
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 200),
|
||
onTimeout: () => throw Exception('端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
} catch (_) {
|
||
KRLogUtil.kr_w('⚠️ 重试订阅统计流时端口不可用，跳过', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
await _kr_subscribeToStats(); // 🔧 UI阻塞修复：使用await
|
||
KRLogUtil.kr_i('✅ 统计数据流重试订阅成功', tag: 'SingBox');
|
||
} catch (e2) {
|
||
KRLogUtil.kr_e('❌ 统计数据流重试订阅失败: $e2', tag: 'SingBox');
|
||
}
|
||
});
|
||
}
|
||
|
||
// 🔧 关键修复：订阅分组数据流
|
||
try {
|
||
// 【关键】在执行订阅前再次检查停止标志
|
||
if (_stopRequested) {
|
||
await KRFileLogger.log('[后台任务] ⏭️ 停止标志已设置，取消分组订阅 - ${DateTime.now()}');
|
||
return;
|
||
}
|
||
|
||
await KRFileLogger.log('[后台任务] 🟡 开始订阅分组数据流 - ${DateTime.now()}');
|
||
KRLogUtil.kr_i('📋 开始订阅分组数据流...', tag: 'SingBox');
|
||
await _kr_subscribeToGroups(); // 🔧 UI阻塞修复：使用await确保让出控制权
|
||
KRLogUtil.kr_i('✅ 分组数据流订阅成功', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ✅ 分组数据流订阅成功 - ${DateTime.now()}');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 分组数据流订阅失败（稍后重试）: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ❌ 分组数据流订阅失败: $e - ${DateTime.now()}');
|
||
// 如果第一次失败，再等待一段时间重试
|
||
Future.delayed(const Duration(milliseconds: 2000), () async {
|
||
// 🔧 重试前检查端口可用性，避免 FFI 阻塞
|
||
try {
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 200),
|
||
onTimeout: () => throw Exception('端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
} catch (_) {
|
||
KRLogUtil.kr_w('⚠️ 重试订阅分组流时端口不可用，跳过', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
await _kr_subscribeToGroups(); // 🔧 UI阻塞修复：使用await
|
||
KRLogUtil.kr_i('✅ 分组数据流重试订阅成功', tag: 'SingBox');
|
||
} catch (e2) {
|
||
KRLogUtil.kr_e('❌ 分组数据流重试订阅失败: $e2', tag: 'SingBox');
|
||
}
|
||
});
|
||
}
|
||
|
||
// 🔧 关键修复：恢复用户选择的节点
|
||
try {
|
||
// 【关键】在执行节点恢复前再次检查停止标志
|
||
if (_stopRequested) {
|
||
await KRFileLogger.log('[后台任务] ⏭️ 停止标志已设置，取消节点恢复 - ${DateTime.now()}');
|
||
return;
|
||
}
|
||
|
||
final nodeRestoreStartTime = DateTime.now();
|
||
await KRFileLogger.log('[后台任务] 🟡 开始恢复用户选择的节点 - $nodeRestoreStartTime');
|
||
final selectedNode = await KRSecureStorage().kr_readData(key: _keySelectedNode);
|
||
if (selectedNode != null && selectedNode.isNotEmpty && selectedNode != 'auto') {
|
||
KRLogUtil.kr_i('🎯 恢复用户选择的节点: $selectedNode', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] 🟡 找到保存的节点: $selectedNode - ${DateTime.now()}');
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 启动后恢复节点选择: $selectedNode');
|
||
}
|
||
|
||
// 🔧 关键修复：等待活动组准备就绪，而不是固定延迟
|
||
// 这是解决"连接后 selected=auto"问题的关键
|
||
KRLogUtil.kr_i('⏳ 等待活动组准备就绪...', tag: 'SingBox');
|
||
final groupWaitStartTime = DateTime.now();
|
||
await KRFileLogger.log('[后台任务] ⏳ 开始等待活动组准备就绪 - $groupWaitStartTime');
|
||
int waitCount = 0;
|
||
const maxWaitCount = 25; // 最多等待 5 秒 (25 * 200ms)
|
||
while (kr_activeGroups.isEmpty && waitCount < maxWaitCount) {
|
||
await Future.delayed(const Duration(milliseconds: 200));
|
||
waitCount++;
|
||
if (waitCount % 5 == 0) {
|
||
KRLogUtil.kr_d('⏳ 等待活动组... ($waitCount/$maxWaitCount)', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ⏳ 等待活动组进行中... (${waitCount}/$maxWaitCount, 已耗时 ${DateTime.now().difference(groupWaitStartTime).inMilliseconds}ms) - ${DateTime.now()}');
|
||
}
|
||
}
|
||
|
||
if (kr_activeGroups.isEmpty) {
|
||
KRLogUtil.kr_w('⚠️ 等待活动组超时，仍尝试恢复节点', tag: 'SingBox');
|
||
final groupWaitDuration = DateTime.now().difference(groupWaitStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[后台任务] ⚠️ 等待活动组超时 (${groupWaitDuration}ms) - ${DateTime.now()}');
|
||
} else {
|
||
KRLogUtil.kr_i('✅ 活动组已就绪，数量: ${kr_activeGroups.length}', tag: 'SingBox');
|
||
final groupWaitDuration = DateTime.now().difference(groupWaitStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[后台任务] ✅ 活动组已就绪，数量: ${kr_activeGroups.length} (耗时 ${groupWaitDuration}ms) - ${DateTime.now()}');
|
||
}
|
||
|
||
// 🔧 关键修复：使用 await 等待节点切换完成
|
||
try {
|
||
final switchStartTime = DateTime.now();
|
||
await KRFileLogger.log('[后台任务] 🟡 开始恢复节点切换: $selectedNode - $switchStartTime');
|
||
await kr_selectOutbound(selectedNode);
|
||
KRLogUtil.kr_i('✅ 节点已切换到用户选择: $selectedNode', tag: 'SingBox');
|
||
final switchDuration = DateTime.now().difference(switchStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[后台任务] ✅ 节点切换成功: $selectedNode (耗时 ${switchDuration}ms) - ${DateTime.now()}');
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 节点切换成功: $selectedNode');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 节点切换失败: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ❌ 节点切换失败: $e - ${DateTime.now()}');
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 节点切换失败: $e');
|
||
}
|
||
}
|
||
|
||
final nodeRestoreDuration = DateTime.now().difference(nodeRestoreStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[后台任务] ✅ 节点恢复流程完成（总耗时 ${nodeRestoreDuration}ms）- ${DateTime.now()}');
|
||
} else {
|
||
KRLogUtil.kr_i('ℹ️ 没有保存的节点选择或为auto，使用默认配置', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ℹ️ 没有保存的节点选择或为auto - ${DateTime.now()}');
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 没有保存的节点选择，使用默认');
|
||
}
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 恢复节点选择失败: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] ❌ 恢复节点选择失败: $e - ${DateTime.now()}');
|
||
if (kDebugMode) {
|
||
KRFileLogger.log('[黑屏调试] 🔵 恢复节点选择失败: $e');
|
||
}
|
||
}
|
||
|
||
final backgroundDuration = DateTime.now().difference(backgroundStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[后台任务] 🟢 所有后台任务完成（总耗时 ${backgroundDuration}ms）- ${DateTime.now()}');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('💥 后台任务异常: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[后台任务] 💥 后台任务异常: $e - ${DateTime.now()}');
|
||
}
|
||
});
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('💥 SingBox 启动异常: $e', tag: 'SingBox');
|
||
KRLogUtil.kr_e('📚 错误堆栈: $stackTrace', tag: 'SingBox');
|
||
// 不需要手动设置状态，libcore 会自动处理
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
/// 停止服务
|
||
Future<void> kr_stop() async {
|
||
// 🔧 文件日志：记录 kr_stop() 调用 + 时间戳
|
||
final clickTime = DateTime.now();
|
||
await KRFileLogger.log('[kr_stop] ⏱️ 用户点击关闭 VPN - $clickTime');
|
||
|
||
// 🔧 文件日志：等待 Lock + 时间戳
|
||
final beforeLock = DateTime.now();
|
||
await KRFileLogger.log('[kr_stop] ⏱️ 开始等待 Lock... - $beforeLock');
|
||
|
||
// ❌ 关键修复：添加 Lock 保护，防止 kr_start() 和 kr_stop() 并发执行
|
||
// 快速连续点击开关时，此 Lock 会序列化所有操作，防止 UI 堵塞
|
||
return _startStopLock.synchronized(() async {
|
||
final afterLock = DateTime.now();
|
||
final lockWaitMs = afterLock.difference(beforeLock).inMilliseconds;
|
||
await KRFileLogger.log('[kr_stop] ✅ Lock 已获取（等待 ${lockWaitMs}ms）- $afterLock');
|
||
|
||
// 【关键】设置停止标志，通知后台任务停止执行
|
||
// 这会让正在执行或即将执行的后台任务立即返回，避免竞态条件
|
||
_stopRequested = true;
|
||
await KRFileLogger.log('[kr_stop] 🔴 设置停止标志，通知后台任务立即停止执行 - ${DateTime.now()}');
|
||
|
||
try {
|
||
final beforeInternal = DateTime.now();
|
||
await _kr_stopInternal();
|
||
final afterInternal = DateTime.now();
|
||
final internalMs = afterInternal.difference(beforeInternal).inMilliseconds;
|
||
await KRFileLogger.log('[kr_stop] ✅ _kr_stopInternal() 完成（耗时 ${internalMs}ms）- $afterInternal');
|
||
} catch (e) {
|
||
await KRFileLogger.log('[kr_stop] ❌ _kr_stopInternal() 异常: $e - ${DateTime.now()}');
|
||
rethrow;
|
||
} finally {
|
||
// 在返回之前重置标志，为下一次启动做准备
|
||
_stopRequested = false;
|
||
await KRFileLogger.log('[kr_stop] 🟢 停止标志已重置，为下一次启动做准备 - ${DateTime.now()}');
|
||
}
|
||
});
|
||
}
|
||
|
||
/// 实际的停止逻辑（被 Lock 保护）
|
||
Future<void> _kr_stopInternal() async {
|
||
final stopInternalStartTime = DateTime.now();
|
||
await KRFileLogger.log('[_kr_stopInternal] 🔴 _kr_stopInternal 方法开始执行 - $stopInternalStartTime');
|
||
|
||
// ✅ DNS 由 libcore.dll 自动管理
|
||
try {
|
||
KRLogUtil.kr_i('🛑 停止 SingBox 服务...', tag: 'SingBox');
|
||
|
||
// 取消节点选择监控定时器
|
||
_nodeSelectionTimer?.cancel();
|
||
_nodeSelectionTimer = null;
|
||
KRLogUtil.kr_i('✅ 节点选择监控已停止', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_stopInternal] ✅ 节点选择监控已停止 - ${DateTime.now()}');
|
||
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
|
||
// 添加超时保护,防止 stop() 调用阻塞
|
||
// 🔧 超时时间 10 秒，确保 libcore 完成清理
|
||
try {
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ⏳ 步骤: 调用 stop (libcore.dll)...');
|
||
final stopStartTime = DateTime.now();
|
||
await KRFileLogger.log('[_kr_stopInternal] 开始 kr_singBox.stop() - ${DateTime.now()}');
|
||
await kr_singBox.stop().run().timeout(
|
||
const Duration(seconds: 10), // ← 从 3 秒延长到 10 秒
|
||
onTimeout: () {
|
||
KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ⚠️ stop 超时(10秒)');
|
||
KRLogUtil.kr_w('⚠️ 停止操作超时(10秒)，强制继续', tag: 'SingBox');
|
||
return const Left('timeout');
|
||
},
|
||
);
|
||
final stopDuration = DateTime.now().difference(stopStartTime).inMilliseconds;
|
||
await KRFileLogger.log('[黑屏调试] [${DateTime.now()}] ✅ stop 完成: 耗时 ${stopDuration}ms');
|
||
await KRFileLogger.log('[_kr_stopInternal] kr_singBox.stop() 完成 - ${DateTime.now()}');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 停止操作失败（可能已经停止）: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_stopInternal] kr_singBox.stop() 异常: $e - ${DateTime.now()}');
|
||
// 继续执行清理操作
|
||
}
|
||
|
||
// ✅ DNS 和系统代理都由 Go 后端 (libcore.dll) 自动管理
|
||
// 参考 Hiddify 实现：sing-box 内部有完整的 DNS 代理机制，不需要手动恢复系统 DNS
|
||
await KRFileLogger.log('[_kr_stopInternal] ℹ️ DNS 由 libcore 自动管理 - ${DateTime.now()}');
|
||
|
||
// 🍎 macOS 专用：清除 SOCKS5 系统代理
|
||
if (Platform.isMacOS) {
|
||
await _kr_setMacOSSocks5Proxy(false);
|
||
}
|
||
|
||
// 🔧 P0-1: 明确清理 groups 和 stats 订阅
|
||
final subscriptionCleanStartTime = DateTime.now();
|
||
await KRFileLogger.log('[_kr_stopInternal] 🔴 开始清理订阅 - $subscriptionCleanStartTime');
|
||
KRLogUtil.kr_i('🧹 清理 command client 订阅...', tag: 'SingBox');
|
||
|
||
// 清理 groups 订阅
|
||
try {
|
||
await KRFileLogger.log('[_kr_stopInternal] 🟡 清理Groups订阅中 - ${DateTime.now()}');
|
||
_subscriptionMap[_SubscriptionType.groups]?.cancel();
|
||
_subscriptionMap.remove(_SubscriptionType.groups);
|
||
KRLogUtil.kr_i('✅ Groups 订阅已取消', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_stopInternal] ✅ Groups 订阅已取消 - ${DateTime.now()}');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ Groups 订阅取消失败: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_stopInternal] ❌ Groups 订阅取消失败: $e - ${DateTime.now()}');
|
||
}
|
||
|
||
// 清理 stats 订阅
|
||
try {
|
||
await KRFileLogger.log('[_kr_stopInternal] 🟡 清理Stats订阅中 - ${DateTime.now()}');
|
||
_subscriptionMap[_SubscriptionType.stats]?.cancel();
|
||
_subscriptionMap.remove(_SubscriptionType.stats);
|
||
KRLogUtil.kr_i('✅ Stats 订阅已取消', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_stopInternal] ✅ Stats 订阅已取消 - ${DateTime.now()}');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ Stats 订阅取消失败: $e', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_stopInternal] ❌ Stats 订阅取消失败: $e - ${DateTime.now()}');
|
||
}
|
||
|
||
// 从列表中清除非 Status 项（向后兼容）
|
||
await KRFileLogger.log('[_kr_stopInternal] 🟡 清理其他订阅中 - ${DateTime.now()}');
|
||
final subscriptionsToCancel = _kr_subscriptions.where((sub) {
|
||
final hashStr = sub.hashCode.toString();
|
||
return !hashStr.contains('Status'); // 不取消状态订阅
|
||
}).toList();
|
||
|
||
for (var subscription in subscriptionsToCancel) {
|
||
_kr_subscriptions.remove(subscription);
|
||
}
|
||
|
||
final subscriptionCleanDuration = DateTime.now().difference(subscriptionCleanStartTime).inMilliseconds;
|
||
KRLogUtil.kr_i('✅ 订阅清理完成，剩余订阅数: ${_kr_subscriptions.length}', tag: 'SingBox');
|
||
await KRFileLogger.log('[_kr_stopInternal] ✅ 订阅清理完成（耗时: ${subscriptionCleanDuration}ms），剩余订阅数: ${_kr_subscriptions.length} - ${DateTime.now()}');
|
||
|
||
// 不手动设置状态，由 libcore 通过 status stream 自动发送 Stopped 事件
|
||
KRLogUtil.kr_i('✅ SingBox 停止请求已发送', tag: 'SingBox');
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('停止服务时出错: $e');
|
||
KRLogUtil.kr_e('错误堆栈: $stackTrace');
|
||
|
||
// ✅ DNS 由 libcore 自动管理，无需手动恢复
|
||
|
||
// 不手动设置状态，信任 libcore 的状态管理
|
||
rethrow;
|
||
} finally {
|
||
// ✅ 关键修复：系统代理恢复改为异步后台执行，不在 finally 块中 await
|
||
// 这样 kr_stop() 可以立即返回，不被注册表操作阻塞
|
||
final finallyStartTime = DateTime.now();
|
||
await KRFileLogger.log('[_kr_stopInternal] 🔴 finally 块开始执行 - $finallyStartTime');
|
||
|
||
// ✅ 系统代理恢复由 Go 后端 (libcore.dll) 自动处理
|
||
// 原因：libcore.stop() 会自动恢复系统代理设置
|
||
// 参考 Hiddify 实现：Dart 层不再手动调用注册表或 WinINet API
|
||
await KRFileLogger.log('[_kr_stopInternal] ℹ️ 系统代理恢复由 libcore 自动管理 - ${DateTime.now()}');
|
||
|
||
// 最后的诊断日志
|
||
final stopInternalEndTime = DateTime.now();
|
||
await KRFileLogger.log('[_kr_stopInternal] 🟢 _kr_stopInternal 方法即将退出 - $stopInternalEndTime');
|
||
}
|
||
}
|
||
|
||
/// 🪟 Windows：Start 之前检查 old command server 端口占用情况
|
||
///
|
||
/// ✅ 极限修复：完全跳过 Windows 端口检查！
|
||
/// 原因：
|
||
/// 1. netstat、powershell、taskkill 都是系统命令，每个 0.5-1 秒
|
||
/// 2. 连续调用导致 2-3 秒的累计卡顿
|
||
/// 3. 造成 icon 停止转动、整个框架卡死
|
||
/// 4. libcore 已经有完整的端口冲突处理逻辑
|
||
///
|
||
/// 相信 libcore 的自动重试机制，比强制同步检查更可靠！
|
||
Future<void> _kr_preflightWindowsCommandServerPort() async {
|
||
if (!Platform.isWindows) return;
|
||
|
||
KRLogUtil.kr_i('⏭️ 跳过 Windows 端口预检查，相信 libcore 的自动处理机制', tag: 'SingBox');
|
||
// 完全不做检查，直接返回
|
||
// libcore 会自动处理所有的端口冲突情况
|
||
}
|
||
|
||
// ✅ 系统代理设置/恢复已移交给 Go 后端 (libcore.dll) 自动处理
|
||
// 参考 Hiddify 实现：通过 changeOptions() 传递 setSystemProxy: true
|
||
// libcore 在 start() 时自动设置代理，在 stop() 时自动恢复
|
||
// 优势：
|
||
// ✅ 无黑窗问题（Go 后端内部处理，不执行外部命令）
|
||
// ✅ 更快速（无进程启动开销）
|
||
// ✅ 更可靠（由 sing-box 核心统一管理）
|
||
|
||
/// Windows: cleanup fixed command server port on logout.
|
||
/// Returns a user-facing warning message if another process owns the port.
|
||
Future<String?> kr_cleanupWindowsCommandServerPortOnLogout() async {
|
||
if (!Platform.isWindows) return null;
|
||
|
||
try {
|
||
final pidInUse = await _kr_getListeningPidByPort(_krWindowsCommandServerPort);
|
||
if (pidInUse == null) return null;
|
||
|
||
final processName = await _kr_getProcessNameByPid(pidInUse);
|
||
final currentExeName = p.basename(Platform.resolvedExecutable).toLowerCase();
|
||
final normalizedProcessName = processName?.toLowerCase();
|
||
|
||
if (normalizedProcessName != null && normalizedProcessName == currentExeName) {
|
||
KRLogUtil.kr_w(
|
||
'logout cleanup: detected port $_krWindowsCommandServerPort in use by self (pid=$pidInUse), killing',
|
||
tag: 'SingBox',
|
||
);
|
||
final killed = await _kr_killProcess(pidInUse);
|
||
if (!killed) {
|
||
KRLogUtil.kr_w(
|
||
'logout cleanup: failed to kill process (pid=$pidInUse)',
|
||
tag: 'SingBox',
|
||
);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
final displayName = processName ?? 'unknown';
|
||
return '当前有其他进程占用$_krWindowsCommandServerPort端口，进程名: $displayName，Pid: $pidInUse，请手动关闭';
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('logout cleanup: port check failed: $e', tag: 'SingBox');
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// Windows: get the listening PID for a port (LISTEN only).
|
||
Future<int?> _kr_getListeningPidByPort(int port) async {
|
||
if (!Platform.isWindows) return null;
|
||
|
||
// Use numeric output to avoid reverse DNS lookups, which can stall when DNS is unstable.
|
||
final result = await KRWindowsProcessUtil.runHidden('netstat', ['-ano', '-p', 'tcp', '-n']);
|
||
if (result.exitCode != 0) {
|
||
KRLogUtil.kr_w('⚠️ netstat 执行失败: ${result.stderr}', tag: 'SingBox');
|
||
return null;
|
||
}
|
||
|
||
final output = result.stdout.toString();
|
||
final lines = output.split(RegExp(r'\r?\n'));
|
||
for (final rawLine in lines) {
|
||
final line = rawLine.trim();
|
||
if (line.isEmpty) continue;
|
||
if (!line.startsWith('TCP')) continue;
|
||
|
||
final parts = line.split(RegExp(r'\s+'));
|
||
// 预期格式: TCP <local> <foreign> <state> <pid>
|
||
if (parts.length < 4) continue;
|
||
|
||
final local = parts.length >= 2 ? parts[1] : '';
|
||
final foreign = parts.length >= 3 ? parts[2] : '';
|
||
final pidStr = parts.isNotEmpty ? parts.last : '';
|
||
|
||
// 🔧 P2-1: 改进端口检测精度 - 使用更精确的正则匹配
|
||
// 监听行 foreign 一般为 0.0.0.0:0 或 [::]:0（避免依赖 LISTENING 文本是否本地化）
|
||
final isListeningRow = RegExp(r'(0\.0\.0\.0|::|.*?):\s*0\s*$').hasMatch(foreign);
|
||
if (!isListeningRow) continue;
|
||
|
||
// 精确匹配端口号（不使用字符串 endsWith，避免误匹配）
|
||
// 例如: 127.0.0.1:51213 或 [::1]:51213 或 *:51213
|
||
final portPattern = RegExp(r':\s*$port\s*$');
|
||
if (!portPattern.hasMatch(local)) continue;
|
||
|
||
final pidValue = int.tryParse(pidStr.trim());
|
||
if (pidValue != null && pidValue > 0) {
|
||
KRLogUtil.kr_d(
|
||
'🔍 端口 $port 被进程 $pidValue 占用 (local: $local, foreign: $foreign)',
|
||
tag: 'SingBox',
|
||
);
|
||
return pidValue;
|
||
}
|
||
}
|
||
|
||
KRLogUtil.kr_d('✅ 端口 $port 未被占用', tag: 'SingBox');
|
||
return null;
|
||
}
|
||
|
||
Future<String?> _kr_getProcessNameByPid(int pidValue) async {
|
||
if (!Platform.isWindows) return null;
|
||
|
||
try {
|
||
final result = await KRWindowsProcessUtil.runHidden('tasklist', [
|
||
'/FI',
|
||
'PID eq $pidValue',
|
||
'/FO',
|
||
'CSV',
|
||
'/NH',
|
||
]);
|
||
if (result.exitCode != 0) {
|
||
KRLogUtil.kr_w('⚠️ tasklist 执行失败: ${result.stderr}', tag: 'SingBox');
|
||
return null;
|
||
}
|
||
|
||
final stdout = result.stdout.toString().trim();
|
||
if (stdout.isEmpty) return null;
|
||
if (stdout.startsWith('INFO:')) return null;
|
||
|
||
// CSV 第一列为 Image Name，例如: "BearVPN.exe","1234",...
|
||
final firstLine = stdout.split(RegExp(r'\r?\n')).first.trim();
|
||
final match = RegExp(r'^"([^"]+)"').firstMatch(firstLine);
|
||
return match?.group(1);
|
||
} catch (e) {
|
||
// 🔧 P2-8: 读/写竞争条件 - 捕获异常，防止进程查询导致的崩溃
|
||
KRLogUtil.kr_w('⚠️ 进程信息查询异常: $e', tag: 'SingBox');
|
||
return null;
|
||
}
|
||
}
|
||
|
||
Future<bool> _kr_killProcess(int pidValue) async {
|
||
if (!Platform.isWindows) return false;
|
||
|
||
final result = await KRWindowsProcessUtil.runHidden('taskkill', [
|
||
'/PID',
|
||
pidValue.toString(),
|
||
'/T',
|
||
'/F',
|
||
]);
|
||
if (result.exitCode == 0) return true;
|
||
|
||
KRLogUtil.kr_w(
|
||
'⚠️ taskkill 失败: exitCode=${result.exitCode}, stderr=${result.stderr}, stdout=${result.stdout}',
|
||
tag: 'SingBox',
|
||
);
|
||
return false;
|
||
}
|
||
|
||
Future<bool> _kr_waitPortFree(int port, {required Duration timeout}) async {
|
||
final deadline = DateTime.now().add(timeout);
|
||
while (DateTime.now().isBefore(deadline)) {
|
||
final pidInUse = await _kr_getListeningPidByPort(port);
|
||
if (pidInUse == null) return true;
|
||
await Future.delayed(const Duration(milliseconds: 200));
|
||
}
|
||
return false;
|
||
}
|
||
|
||
///
|
||
void kr_updateAdBlockEnabled(bool bl) async {
|
||
final oOption = _getConfigOption();
|
||
|
||
oOption["block-ads"] = bl;
|
||
final op = SingboxConfigOption.fromJson(oOption);
|
||
|
||
await kr_singBox.changeOptions(op)
|
||
..map((r) {}).mapLeft((err) {
|
||
KRLogUtil.kr_e('更新广告拦截失败: $err');
|
||
}).run();
|
||
if (kr_status.value == SingboxStarted()) {
|
||
await kr_restart();
|
||
}
|
||
kr_blockAds.value = bl;
|
||
}
|
||
|
||
Future<void> kr_restart() async {
|
||
KRLogUtil.kr_i('🔄 重启 SingBox...', tag: 'SingBox');
|
||
|
||
// 🔧 P0-2: 改进异常处理 - stop 失败也要尝试 start
|
||
// 🔧 P1-1: 优化网络抖动 - 监听状态变化而非固定延迟
|
||
// ✅ DNS/代理 由 libcore.dll 自动管理
|
||
try {
|
||
// 1. 先停止
|
||
try {
|
||
await kr_stop();
|
||
} catch (stopError) {
|
||
KRLogUtil.kr_e('❌ 停止失败: $stopError，仍尝试启动', tag: 'SingBox');
|
||
// 不 rethrow，继续尝试启动
|
||
}
|
||
|
||
// 🔧 P1-1: 2. 等待完全停止 - 监听状态而非固定延迟（减少网络中断时间）
|
||
try {
|
||
// 如果已经是停止状态，直接继续
|
||
if (kr_status.value is SingboxStopped) {
|
||
KRLogUtil.kr_i('✅ SingBox 已是停止状态，立即启动', tag: 'SingBox');
|
||
} else {
|
||
// 等待状态变为停止，最多等待2秒（比原来的盲等500ms更聪明）
|
||
final completer = Completer<void>();
|
||
late final Worker worker;
|
||
|
||
worker = ever(kr_status, (status) {
|
||
if (status is SingboxStopped) {
|
||
if (!completer.isCompleted) {
|
||
completer.complete();
|
||
worker.dispose();
|
||
KRLogUtil.kr_i('✅ 检测到 SingBox 已停止，立即启动新实例', tag: 'SingBox');
|
||
}
|
||
}
|
||
});
|
||
|
||
await completer.future.timeout(
|
||
const Duration(seconds: 2),
|
||
onTimeout: () {
|
||
KRLogUtil.kr_w('⏱️ 等待停止状态超时(2s)，使用备用延迟', tag: 'SingBox');
|
||
worker.dispose();
|
||
},
|
||
);
|
||
}
|
||
} catch (stateError) {
|
||
KRLogUtil.kr_w('⚠️ 状态监听异常: $stateError，使用备用延迟', tag: 'SingBox');
|
||
// 备用：使用较短的延迟(300ms代替原来的500ms)
|
||
await Future.delayed(const Duration(milliseconds: 300));
|
||
}
|
||
|
||
// 🔧 P1-1: 3. 重新启动
|
||
try {
|
||
await kr_start();
|
||
KRLogUtil.kr_i('✅ SingBox 重启完成', tag: 'SingBox');
|
||
} catch (startError) {
|
||
KRLogUtil.kr_e('❌ 重启失败: $startError', tag: 'SingBox');
|
||
rethrow; // 只有启动失败才抛异常
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 重启异常: $e', tag: 'SingBox');
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
//// 设置出站模式
|
||
Future<void> kr_updateConnectionType(KRConnectionType newType) async {
|
||
final previousType = kr_connectionType.value; // 保存原模式用于失败时回滚
|
||
|
||
try {
|
||
KRLogUtil.kr_i('🔄 开始更新连接类型...', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📊 当前类型: ${kr_connectionType.value}', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📊 新类型: $newType', tag: 'SingBox');
|
||
|
||
if (kr_connectionType.value == newType) {
|
||
KRLogUtil.kr_i('⚠️ 连接类型相同，无需更新', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
// ✅ 改进：直接尝试切换（不做权限检查避免黑屏）
|
||
// 关键改进：保存原模式，失败时回滚以防止自动重连机制无限循环
|
||
KRLogUtil.kr_i('📝 尝试切换模式到: $newType（原模式: $previousType）', tag: 'SingBox');
|
||
|
||
kr_connectionType.value = newType;
|
||
|
||
final oOption = _getConfigOption();
|
||
|
||
var mode = "";
|
||
switch (newType) {
|
||
case KRConnectionType.global:
|
||
mode = "other";
|
||
KRLogUtil.kr_i('🌍 切换到全局代理模式', tag: 'SingBox');
|
||
break;
|
||
case KRConnectionType.rule:
|
||
mode = KRCountryUtil.kr_getCurrentCountryCode();
|
||
KRLogUtil.kr_i('🎯 切换到规则代理模式: $mode', tag: 'SingBox');
|
||
break;
|
||
// case KRConnectionType.direct:
|
||
// mode = "direct";
|
||
// break;
|
||
}
|
||
oOption["region"] = mode;
|
||
KRLogUtil.kr_i('📝 更新 region 配置: $mode', tag: 'SingBox');
|
||
|
||
final op = SingboxConfigOption.fromJson(oOption);
|
||
KRLogUtil.kr_i('📄 配置选项: ${oOption.toString()}', tag: 'SingBox');
|
||
|
||
await kr_singBox.changeOptions(op)
|
||
..map((r) {
|
||
KRLogUtil.kr_i('✅ 连接类型更新成功', tag: 'SingBox');
|
||
}).mapLeft((err) {
|
||
KRLogUtil.kr_e('❌ 更新连接类型失败: $err', tag: 'SingBox');
|
||
throw err;
|
||
}).run();
|
||
|
||
if (kr_status.value == SingboxStarted()) {
|
||
KRLogUtil.kr_i('🔄 VPN已启动，准备重启以应用新配置...', tag: 'SingBox');
|
||
try {
|
||
// 重启前添加超时保护（10秒），避免卡顿
|
||
await kr_restart().timeout(
|
||
const Duration(seconds: 10),
|
||
onTimeout: () {
|
||
KRLogUtil.kr_w('⏱️ VPN重启超时(10s)，可能缺少权限', tag: 'SingBox');
|
||
throw TimeoutException('VPN重启超时，请检查是否需要管理员权限');
|
||
},
|
||
);
|
||
KRLogUtil.kr_i('✅ VPN重启完成', tag: 'SingBox');
|
||
} catch (restartError) {
|
||
KRLogUtil.kr_e('❌ VPN重启失败: $restartError', tag: 'SingBox');
|
||
|
||
// 重启失败时回滚模式改变，避免触发自动重连机制无限循环
|
||
KRLogUtil.kr_w('🔙 重启失败，回滚模式到: $previousType', tag: 'SingBox');
|
||
kr_connectionType.value = previousType;
|
||
|
||
// ❌ 关键修复：不要 rethrow，异常已经完整处理（已回滚 + Toast 提示由监听器负责）
|
||
// rethrow;
|
||
}
|
||
} else {
|
||
KRLogUtil.kr_i('ℹ️ VPN未启动，配置已更新', tag: 'SingBox');
|
||
}
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('💥 更新连接类型异常: $e', tag: 'SingBox');
|
||
KRLogUtil.kr_e('📚 错误堆栈: $stackTrace', tag: 'SingBox');
|
||
|
||
// 最终保险：异常时确保回滚模式
|
||
if (kr_connectionType.value != previousType) {
|
||
KRLogUtil.kr_w('🔙 异常捕获，回滚模式到: $previousType', tag: 'SingBox');
|
||
kr_connectionType.value = previousType;
|
||
}
|
||
|
||
// ❌ 关键修复：不要 rethrow
|
||
// 异常已经通过 Toast 由监听器提示，模式已回滚
|
||
// 继续 rethrow 会导致对话框无法关闭，让应用看起来"卡"了
|
||
// rethrow;
|
||
}
|
||
}
|
||
|
||
/// 更新国家设置
|
||
Future<void> kr_updateCountry(KRCountry kr_country) async {
|
||
// 如果国家相同，直接返回
|
||
if (kr_country.kr_code == KRCountryUtil.kr_getCurrentCountryCode()) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
// 更新工具类中的当前国家
|
||
await KRCountryUtil.kr_setCurrentCountry(kr_country);
|
||
// 更新配置选项
|
||
final oOption = _getConfigOption();
|
||
oOption["region"] = kr_country.kr_code;
|
||
final op = SingboxConfigOption.fromJson(oOption);
|
||
|
||
await kr_singBox.changeOptions(op)
|
||
..map((r) {}).mapLeft((err) {
|
||
KRLogUtil.kr_e('更新国家设置失败: $err');
|
||
}).run();
|
||
|
||
// 如果服务正在运行，重启服务
|
||
if (kr_status.value == SingboxStarted()) {
|
||
await kr_restart();
|
||
}
|
||
} catch (err) {
|
||
KRLogUtil.kr_e('更新国家失败: $err');
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
Stream<SingboxStatus> kr_watchStatus() {
|
||
return kr_singBox.watchStatus();
|
||
}
|
||
|
||
Stream<List<SingboxOutboundGroup>> kr_watchGroups() {
|
||
return kr_singBox.watchGroups();
|
||
}
|
||
|
||
// 节点选择监控定时器
|
||
Timer? _nodeSelectionTimer;
|
||
|
||
Future<void> kr_selectOutbound(String tag) async {
|
||
// ========== 关键路径：必需的同步操作 ==========
|
||
// 🔧 P2新: 检查 VPN 是否在运行
|
||
if (kr_status.value is! SingboxStarted) {
|
||
KRLogUtil.kr_w('⚠️ VPN 未运行，无法选择节点: $tag', tag: 'SingBox');
|
||
throw Exception('VPN 未启动，无法选择节点。请先启动 VPN');
|
||
}
|
||
|
||
KRLogUtil.kr_i('🎯 开始选择出站节点: $tag', tag: 'SingBox');
|
||
|
||
// 🔧 关键修复：使用 await 确保保存完成
|
||
try {
|
||
await KRSecureStorage().kr_saveData(key: _keySelectedNode, value: tag);
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('✅ 节点选择已保存: $tag', tag: 'SingBox');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 保存节点选择失败: $e', tag: 'SingBox');
|
||
}
|
||
|
||
// 🔧 关键修复：使用 await 确保 command client 初始化完成
|
||
try {
|
||
await _kr_ensureCommandClientInitialized();
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('✅ Command client 已就绪，执行节点切换', tag: 'SingBox');
|
||
}
|
||
|
||
// 🔧 关键修复：使用正确的 group tag
|
||
// libcore 生成的selector组的tag是"proxy"而不是"select"
|
||
final selectorGroupTag = kr_activeGroups.any((g) => g.tag == 'select') ? 'select' : 'proxy';
|
||
|
||
// ⚡ 关键优化：核心 API 调用
|
||
await _kr_selectOutboundWithRetry(selectorGroupTag, tag, maxAttempts: 3, initialDelay: 50);
|
||
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('✅ 节点切换API调用完成: $tag', tag: 'SingBox');
|
||
}
|
||
|
||
// ========== 关键路径结束！以下操作都在后台进行 ==========
|
||
// ⚡ 后台任务：验证 + 刷新 + 监控（不影响返回）
|
||
unawaited(_kr_backgroundNodeVerificationAndRefresh(tag));
|
||
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 节点选择失败: $e', tag: 'SingBox');
|
||
rethrow; // 抛出异常，让调用者知道失败了
|
||
}
|
||
}
|
||
|
||
/// ⚡ 后台验证和刷新（不影响 UI 响应）
|
||
/// 包含：验证节点选择 + TUN 模式刷新 + 启动监控定时器
|
||
Future<void> _kr_backgroundNodeVerificationAndRefresh(String tag) async {
|
||
try {
|
||
// 第一步：等待一点时间让活动组更新
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
|
||
// 第二步：后台验证节点选择
|
||
await _krVerifyNodeSelectionInBackground(tag);
|
||
|
||
// 第三步：TUN 模式刷新连接
|
||
if (Platform.isWindows && kr_connectionType.value == KRConnectionType.global) {
|
||
await _kr_tunModeRefreshInBackground(tag);
|
||
}
|
||
|
||
// 第四步：启动节点选择监控（防止被 auto 覆盖）
|
||
_kr_startNodeSelectionMonitoring(tag);
|
||
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 后台任务异常（不影响节点切换）: $e', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
/// 后台验证节点选择（异步，失败只记日志）
|
||
Future<void> _krVerifyNodeSelectionInBackground(String tag) async {
|
||
try {
|
||
final selectGroup = kr_activeGroups.firstWhere(
|
||
(group) => group.tag == 'select',
|
||
orElse: () => throw Exception('未找到 "select" 选择器组'),
|
||
);
|
||
|
||
if (selectGroup.selected != tag) {
|
||
KRLogUtil.kr_w('⚠️ 节点验证失败: 期望 $tag, 实际 ${selectGroup.selected}', tag: 'SingBox');
|
||
} else if (kDebugMode) {
|
||
KRLogUtil.kr_d('✅ 节点验证成功: $tag', tag: 'SingBox');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 节点验证异常: $e', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
/// TUN 模式连接刷新（后台执行）
|
||
Future<void> _kr_tunModeRefreshInBackground(String tag) async {
|
||
try {
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('🔄 TUN 模式：后台刷新连接...', tag: 'SingBox');
|
||
}
|
||
|
||
final selectorGroupTag = kr_activeGroups.any((g) => g.tag == 'select')
|
||
? 'select'
|
||
: 'proxy';
|
||
|
||
// 第一步：urlTest 创建新连接
|
||
final testResult = await kr_singBox.urlTest(selectorGroupTag).run().timeout(
|
||
const Duration(seconds: 3),
|
||
onTimeout: () {
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('⚠️ urlTest 超时', tag: 'SingBox');
|
||
}
|
||
return const Left('timeout');
|
||
},
|
||
);
|
||
|
||
testResult.match(
|
||
(error) {
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('⚠️ urlTest 失败: $error', tag: 'SingBox');
|
||
}
|
||
},
|
||
(_) {
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('✅ urlTest 完成', tag: 'SingBox');
|
||
}
|
||
},
|
||
);
|
||
|
||
// 第二步：HTTP 刷新（最有效）
|
||
await _kr_forceHttpConnectionRefresh(tag);
|
||
|
||
// 第三步：等待连接稳定
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('✅ TUN 模式连接刷新完成', tag: 'SingBox');
|
||
}
|
||
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ TUN 模式刷新异常: $e（不影响节点切换）', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
/// 启动节点选择监控定时器（防止 urltest 自动覆盖）
|
||
void _kr_startNodeSelectionMonitoring(String tag) {
|
||
try {
|
||
_nodeSelectionTimer?.cancel();
|
||
_nodeSelectionTimer = null;
|
||
|
||
if (tag != 'auto') {
|
||
final currentSelectorGroupTag = kr_activeGroups.any((g) => g.tag == 'select')
|
||
? 'select'
|
||
: 'proxy';
|
||
final selectedTag = tag;
|
||
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('🔁 启动节点选择监控: $selectedTag', tag: 'SingBox');
|
||
}
|
||
|
||
_nodeSelectionTimer = Timer.periodic(const Duration(seconds: 20), (timer) {
|
||
try {
|
||
kr_singBox.selectOutbound(currentSelectorGroupTag, selectedTag).run().then((result) {
|
||
result.match(
|
||
(error) {
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('🔁 定时器重选失败: $error', tag: 'SingBox');
|
||
}
|
||
},
|
||
(_) {
|
||
if (kDebugMode) {
|
||
KRLogUtil.kr_d('🔁 定时器重选成功', tag: 'SingBox');
|
||
}
|
||
},
|
||
);
|
||
}).catchError((error) {
|
||
KRLogUtil.kr_w('🔁 定时器异常: $error', tag: 'SingBox');
|
||
});
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('💥 定时器回调异常: $e', tag: 'SingBox');
|
||
timer.cancel();
|
||
_nodeSelectionTimer = null;
|
||
}
|
||
});
|
||
}
|
||
} catch (timerError) {
|
||
KRLogUtil.kr_e('❌ 启动定时器异常: $timerError', tag: 'SingBox');
|
||
_nodeSelectionTimer?.cancel();
|
||
_nodeSelectionTimer = null;
|
||
}
|
||
}
|
||
|
||
/// 配合文件地址
|
||
|
||
Directory get directory =>
|
||
Directory(p.join(kr_configDics.workingDir.path, "configs"));
|
||
File _file(String fileName) {
|
||
return File(p.join(directory.path, "$fileName.json"));
|
||
}
|
||
|
||
File _tempFile(String fileName) => _file("$fileName.tmp");
|
||
|
||
/// 启动节点选择监控定时器，防止用户手动选择被自动策略覆盖
|
||
void kr_startNodeSelectionMonitor(String tag) {
|
||
kr_resetNodeSelectionMonitor();
|
||
if (tag != 'auto') {
|
||
KRLogUtil.kr_i('🔁 启动节点选择监控，防止被 auto 覆盖', tag: 'SingBox');
|
||
_nodeSelectionTimer =
|
||
Timer.periodic(const Duration(seconds: 20), (timer) {
|
||
// 每 20 秒重新选择一次，确保用户选择不被覆盖
|
||
// 使用 then/catchError 避免异常导致 UI 阻塞
|
||
kr_singBox.selectOutbound("select", tag).run().then((result) {
|
||
result.match(
|
||
(error) => KRLogUtil.kr_w('🔁 定时器重选节点失败: $error', tag: 'SingBox'),
|
||
(_) => KRLogUtil.kr_d('🔁 定时器重选节点成功', tag: 'SingBox'),
|
||
);
|
||
}).catchError((error) {
|
||
KRLogUtil.kr_w('🔁 定时器重选节点异常: $error', tag: 'SingBox');
|
||
});
|
||
KRLogUtil.kr_d('🔁 重新确认节点选择: $tag', tag: 'SingBox');
|
||
});
|
||
}
|
||
}
|
||
|
||
/// 重置并停止节点选择监控定时器
|
||
void kr_resetNodeSelectionMonitor() {
|
||
_nodeSelectionTimer?.cancel();
|
||
_nodeSelectionTimer = null;
|
||
KRLogUtil.kr_i('✅ 节点选择监控已停止', tag: 'SingBox');
|
||
}
|
||
|
||
// File tempFile(String fileName) => file("$fileName.tmp");
|
||
|
||
/// ✅ 临时切换模式以完全断开浏览器连接（推荐方案）
|
||
/// 原理：
|
||
/// TUN 模式：浏览器 → 操作系统 → sing-box → 节点（浏览器无法关闭连接）❌
|
||
/// 系统代理：浏览器 → 代理软件 → 节点（代理可强制关闭连接）✅
|
||
/// 流程：
|
||
/// 1. TUN → 系统代理（这时代理会主动关闭所有旧连接）
|
||
/// 2. 发送 HTTP 请求（刷新代理缓存）
|
||
/// 3. 系统代理 → TUN（恢复原状态）
|
||
/// 优点：100% 彻底断开，无残留连接，UX 无感知（<100ms）
|
||
Future<void> _kr_refreshConnectionByModeSwitch(String nodeTag) async {
|
||
if (!Platform.isWindows) {
|
||
// 非 Windows 系统，使用原有的 HTTP 刷新方案
|
||
await _kr_forceHttpConnectionRefresh(nodeTag);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
KRLogUtil.kr_i('🔄 [高级] 临时切换到系统代理以断开所有连接...', tag: 'SingBox');
|
||
final originalMode = kr_connectionType.value;
|
||
|
||
// 第一步：临时切换到系统代理模式
|
||
KRLogUtil.kr_i(' ① 临时切换：TUN → 系统代理模式', tag: 'SingBox');
|
||
await kr_updateConnectionType(KRConnectionType.rule);
|
||
await Future.delayed(const Duration(milliseconds: 100)); // 等待模式切换生效
|
||
|
||
// 第二步：发送 HTTP 请求强制刷新（此时用系统代理）
|
||
KRLogUtil.kr_i(' ② 发送 HTTP 请求（通过系统代理刷新缓存）', tag: 'SingBox');
|
||
await _kr_forceHttpConnectionRefresh(nodeTag);
|
||
|
||
// 第三步：切换回原模式（TUN）
|
||
KRLogUtil.kr_i(' ③ 恢复：系统代理 → TUN 模式', tag: 'SingBox');
|
||
await kr_updateConnectionType(originalMode);
|
||
await Future.delayed(const Duration(milliseconds: 100)); // 等待模式切换生效
|
||
|
||
KRLogUtil.kr_i('✅ [高级] 连接完全刷新完成，浏览器将使用新节点的新连接', tag: 'SingBox');
|
||
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 模式切换刷新异常: $e（节点切换已生效）', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
/// ✅ 激进方案：完全重启 VPN（100% 清理所有连接）
|
||
/// 原理：完全关闭 VPN 再重新启动，所有连接都会断开并重建
|
||
/// 优点：最彻底，无任何残留连接
|
||
/// 缺点：用户会短暂看到"已断开"状态，可能有 DNS 泄漏短暂风险
|
||
Future<void> _kr_restartVpnForNodeSwitch(String nodeTag) async {
|
||
try {
|
||
KRLogUtil.kr_i('🔄 [激进] 重启 VPN 以彻底清理所有连接...', tag: 'SingBox');
|
||
|
||
// 第一步：关闭 VPN（断开所有连接）
|
||
KRLogUtil.kr_i(' ① 停止 VPN', tag: 'SingBox');
|
||
await kr_stop();
|
||
await Future.delayed(const Duration(milliseconds: 300)); // 等待VPN完全停止
|
||
|
||
// 第二步：重新启动 VPN（建立新连接到新节点）
|
||
KRLogUtil.kr_i(' ② 重新启动 VPN', tag: 'SingBox');
|
||
await kr_start();
|
||
|
||
KRLogUtil.kr_i('✅ [激进] VPN 重启完成，所有连接已刷新', tag: 'SingBox');
|
||
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ VPN 重启失败: $e（请手动重新启动）', tag: 'SingBox');
|
||
// 尝试恢复
|
||
try {
|
||
await kr_start();
|
||
} catch (e2) {
|
||
KRLogUtil.kr_e('❌ VPN 恢复启动失败: $e2', tag: 'SingBox');
|
||
}
|
||
}
|
||
}
|
||
|
||
/// ✅ TUN模式连接强制刷新：发送真实 HTTP 请求
|
||
/// 原理：实际的 HTTP 请求会强制建立新的 TCP 连接，让浏览器感知到网络路由变化
|
||
/// 效果：比仅做 urlTest 测试更有效，因为这是真实的数据传输
|
||
Future<void> _kr_forceHttpConnectionRefresh(String nodeTag) async {
|
||
try {
|
||
// 使用多个测试 URL，确保至少有一个能成功
|
||
final testUrls = [
|
||
'http://connectivitycheck.gstatic.com/generate_204', // Google 连接检查
|
||
'http://www.google.com/generate_204',
|
||
'http://ipv4.icanhazip.com/', // IP 检查，会返回当前外网 IP
|
||
];
|
||
|
||
KRLogUtil.kr_i('🔗 使用 HTTP 请求强制刷新连接（节点: $nodeTag）', tag: 'SingBox');
|
||
|
||
for (int i = 0; i < testUrls.length; i++) {
|
||
final httpClient = HttpClient();
|
||
httpClient.connectionTimeout = const Duration(seconds: 2);
|
||
|
||
try {
|
||
final url = testUrls[i];
|
||
KRLogUtil.kr_i(' 尝试 URL[$i]: $url', tag: 'SingBox');
|
||
|
||
// 发送 HTTP 请求（不使用 Dio，直接使用 HttpClient 避免代理）
|
||
final request = await httpClient.getUrl(Uri.parse(url));
|
||
request.headers.set('Connection', 'close'); // 明确关闭连接
|
||
request.headers.set('User-Agent', 'BearVPN/1.0'); // 标识为 BearVPN 请求
|
||
|
||
final response = await request.close().timeout(
|
||
const Duration(seconds: 2),
|
||
);
|
||
|
||
// 消费响应体
|
||
final _ = await response.transform(utf8.decoder).join();
|
||
|
||
KRLogUtil.kr_i('✅ HTTP 刷新成功 ($url)，状态码: ${response.statusCode}', tag: 'SingBox');
|
||
return; // 成功就返回，不需要尝试其他 URL
|
||
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ HTTP 刷新失败 (${testUrls[i]}): $e', tag: 'SingBox');
|
||
// 继续尝试下一个 URL
|
||
if (i < testUrls.length - 1) {
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
}
|
||
} finally {
|
||
// ✅ 关键修复：确保在任何情况下都关闭连接，避免资源泄漏
|
||
httpClient.close();
|
||
}
|
||
}
|
||
|
||
KRLogUtil.kr_w('⚠️ 所有 HTTP 刷新 URL 都失败，但节点切换仍然生效', tag: 'SingBox');
|
||
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 连接刷新异常: $e', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
Future<void> kr_urlTest(String groupTag) async {
|
||
KRLogUtil.kr_i('🧪 开始 URL 测试: $groupTag', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📊 当前活动组数量: ${kr_activeGroups.length}', tag: 'SingBox');
|
||
|
||
// 打印所有活动组信息
|
||
for (int i = 0; i < kr_activeGroups.length; i++) {
|
||
final group = kr_activeGroups[i];
|
||
KRLogUtil.kr_i('📋 活动组[$i]: tag=${group.tag}, type=${group.type}, selected=${group.selected}', tag: 'SingBox');
|
||
for (int j = 0; j < group.items.length; j++) {
|
||
final item = group.items[j];
|
||
KRLogUtil.kr_i(' └─ 节点[$j]: tag=${item.tag}, type=${item.type}, delay=${item.urlTestDelay}', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
try {
|
||
KRLogUtil.kr_i('🚀 调用 SingBox URL 测试 API...', tag: 'SingBox');
|
||
final result = await kr_singBox.urlTest(groupTag).run();
|
||
KRLogUtil.kr_i('✅ URL 测试完成: $groupTag, 结果: $result', tag: 'SingBox');
|
||
|
||
// 等待一段时间让 SingBox 完成测试
|
||
await Future.delayed(const Duration(seconds: 2));
|
||
|
||
// 再次检查活动组状态
|
||
KRLogUtil.kr_i('🔄 测试后活动组状态检查:', tag: 'SingBox');
|
||
for (int i = 0; i < kr_activeGroups.length; i++) {
|
||
final group = kr_activeGroups[i];
|
||
KRLogUtil.kr_i('📋 活动组[$i]: tag=${group.tag}, type=${group.type}, selected=${group.selected}', tag: 'SingBox');
|
||
for (int j = 0; j < group.items.length; j++) {
|
||
final item = group.items[j];
|
||
KRLogUtil.kr_i(' └─ 节点[$j]: tag=${item.tag}, type=${item.type}, delay=${item.urlTestDelay}', tag: 'SingBox');
|
||
}
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ URL 测试失败: $groupTag, 错误: $e', tag: 'SingBox');
|
||
KRLogUtil.kr_e('📚 错误详情: ${e.toString()}', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
/// 🪟 Windows: 检查当前进程是否有管理员权限（TUN 模式需要）
|
||
/// 返回 true 表示有管理员权限，false 表示无权限
|
||
/// ✅ 公开方法：检查 Windows 管理员权限
|
||
/// 返回 true: 有管理员权限，可以使用 TUN 模式
|
||
/// 返回 false: 无管理员权限，只能使用规则/系统代理模式
|
||
Future<bool> kr_checkWindowsAdminPrivilege() async {
|
||
return await _kr_checkWindowsAdminPrivilege();
|
||
}
|
||
|
||
/// 私有方法：内部实现（带缓存）
|
||
/// ✅ 改进：使用 FFI 直接调用 IsUserAnAdmin() Windows API
|
||
/// ⭐ 优化：
|
||
/// - 不启动新进程，无黑屏风险
|
||
/// - 直接内存操作，速度快（1-5ms vs 600ms）
|
||
/// - 零资源开销
|
||
/// - Windows 官方 API，完全可靠
|
||
Future<bool> _kr_checkWindowsAdminPrivilege() async {
|
||
if (!Platform.isWindows) return true;
|
||
|
||
// 检查缓存是否有效
|
||
if (_cachedAdminPrivilege != null && _cachedAdminPrivilegeTime != null) {
|
||
final elapsed = DateTime.now().difference(_cachedAdminPrivilegeTime!);
|
||
if (elapsed < _adminPrivilegeCacheDuration) {
|
||
KRLogUtil.kr_i('📦 使用缓存的管理员权限状态: ${_cachedAdminPrivilege}', tag: 'SingBox');
|
||
return _cachedAdminPrivilege!;
|
||
}
|
||
}
|
||
|
||
try {
|
||
// ✅ 方案 B：使用 FFI 直接调用 IsUserAnAdmin() Windows API
|
||
// 比 Process.run('net session') 快 300 倍，且无黑屏风险
|
||
KRLogUtil.kr_i('🔍 使用 FFI 检查管理员权限（无黑屏）...', tag: 'SingBox');
|
||
|
||
final hasPrivilege = _isUserAnAdminFFI();
|
||
|
||
// 缓存结果
|
||
_cachedAdminPrivilege = hasPrivilege;
|
||
_cachedAdminPrivilegeTime = DateTime.now();
|
||
|
||
if (hasPrivilege) {
|
||
KRLogUtil.kr_i('✅ 检测到管理员权限', tag: 'SingBox');
|
||
} else {
|
||
KRLogUtil.kr_w('⚠️ 未检测到管理员权限，TUN 模式需要管理员权限', tag: 'SingBox');
|
||
}
|
||
|
||
return hasPrivilege;
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 检查管理员权限失败: $e', tag: 'SingBox');
|
||
// 检查失败时返回 false，让用户重新以管理员身份运行
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// 【方案 A】sing-box 进程健康监测
|
||
/// 用于检测 sing-box 是否在启动后不久崩溃
|
||
///
|
||
/// 背景：诊断日志显示
|
||
/// - start() 立即返回成功，8964 端口可连接 ✅
|
||
/// - 1.4 秒后，8964 端口突然无法连接 ❌
|
||
/// - 说明 sing-box 进程在启动后崩溃了
|
||
///
|
||
/// 监测策略：
|
||
/// 1. 启动成功后，立即开始监测
|
||
/// 2. 每隔 500ms 检查一次 8964 端口
|
||
/// 3. 如果连续 3 次无法连接，说明进程崩溃了
|
||
/// 4. 但如果 _stopRequested 为 true，说明用户要求停止，不要恢复！
|
||
Future<void> _monitorSingBoxProcess() async {
|
||
const checkInterval = Duration(milliseconds: 500);
|
||
const maxAttempts = 10; // 监测 5 秒（10 次 * 500ms）
|
||
int failureCount = 0;
|
||
int checkCount = 0;
|
||
|
||
try {
|
||
await KRFileLogger.log('[进程监测] 🟢 开始 sing-box 进程健康监测（每 500ms 检查一次，共 10 次）');
|
||
|
||
for (int i = 0; i < maxAttempts; i++) {
|
||
checkCount++;
|
||
await Future.delayed(checkInterval);
|
||
|
||
// 【关键】检查停止标志：如果用户要求停止，立即返回
|
||
if (_stopRequested) {
|
||
await KRFileLogger.log('[进程监测] ⏭️ 检测到停止标志，监测任务立即返回');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 200),
|
||
onTimeout: () => throw Exception('端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
|
||
// 连接成功，重置失败计数
|
||
failureCount = 0;
|
||
await KRFileLogger.log('[进程监测] ✅ 检查 #$checkCount: 8964 端口可连接（进程正常运行）');
|
||
} catch (e) {
|
||
failureCount++;
|
||
await KRFileLogger.log('[进程监测] ❌ 检查 #$checkCount: 8964 端口无法连接（失败 #$failureCount）');
|
||
|
||
// 如果连续 3 次失败，说明进程崩溃了
|
||
if (failureCount >= 3) {
|
||
// 【关键】但首先检查停止标志！
|
||
if (_stopRequested) {
|
||
await KRFileLogger.log('[进程监测] ⏭️ 连接失败，但用户已要求停止，不触发恢复');
|
||
return;
|
||
}
|
||
|
||
await KRFileLogger.log('[进程监测] 🚨 【严重】连续 3 次无法连接，sing-box 进程已崩溃！');
|
||
await KRFileLogger.log('[进程监测] 🚨 时间：${DateTime.now()}');
|
||
await KRFileLogger.log('[进程监测] 🚨 这可能是导致后续 UI 卡顿的根本原因！');
|
||
|
||
KRLogUtil.kr_e('【严重】sing-box 进程在启动后崩溃了！端口无法连接', tag: 'ProcessMonitor');
|
||
|
||
// 【可选】触发恢复机制：尝试重启 sing-box
|
||
// await _triggerSingBoxRecovery();
|
||
|
||
return; // 停止监测
|
||
}
|
||
}
|
||
}
|
||
|
||
// 监测完成
|
||
await KRFileLogger.log('[进程监测] ✅ 监测完成：sing-box 进程在启动后 5 秒内保持稳定运行');
|
||
KRLogUtil.kr_i('✅ sing-box 进程健康检查通过', tag: 'ProcessMonitor');
|
||
|
||
} catch (e) {
|
||
await KRFileLogger.log('[进程监测] ❌ 监测异常: $e');
|
||
KRLogUtil.kr_e('进程监测异常: $e', tag: 'ProcessMonitor');
|
||
}
|
||
}
|
||
|
||
/// 【方案 A】sing-box 进程恢复机制
|
||
/// 当检测到进程崩溃时，尝试恢复
|
||
///
|
||
/// 改进：
|
||
/// 1. 先尝试优雅关闭（graceful shutdown）
|
||
/// 2. 如果进程仍活着，强制杀死以立即释放端口
|
||
/// 3. 轮询确认端口已释放后再重启
|
||
Future<void> _triggerSingBoxRecovery() async {
|
||
try {
|
||
await KRFileLogger.log('[进程恢复] 🟡 检测到进程崩溃，尝试恢复...');
|
||
KRLogUtil.kr_w('⚠️ sing-box 进程崩溃，尝试恢复...', tag: 'ProcessMonitor');
|
||
|
||
// 1️⃣ 先尝试优雅停止
|
||
try {
|
||
await kr_singBox.stop().run();
|
||
await KRFileLogger.log('[进程恢复] ✅ 已优雅停止旧进程');
|
||
} catch (e) {
|
||
await KRFileLogger.log('[进程恢复] ⚠️ 优雅停止失败（可能已经停止）: $e');
|
||
}
|
||
|
||
// 2️⃣ 等待进程优雅关闭
|
||
await Future.delayed(const Duration(milliseconds: 300));
|
||
|
||
// 3️⃣ 检查进程是否还活着（检查 8964 端口）
|
||
bool processStillAlive = false;
|
||
try {
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 200),
|
||
onTimeout: () => throw Exception('端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
processStillAlive = true;
|
||
await KRFileLogger.log('[进程恢复] ⚠️ 8964 端口仍在被占用，进程未完全关闭');
|
||
} catch (e) {
|
||
processStillAlive = false;
|
||
await KRFileLogger.log('[进程恢复] ✅ 8964 端口已释放，进程已完全关闭');
|
||
}
|
||
|
||
// 4️⃣ 如果进程还活着，强制杀死（taskkill - Windows only）
|
||
bool killSucceeded = true;
|
||
if (processStillAlive) {
|
||
await KRFileLogger.log('[进程恢复] 🔴 进程仍活着，执行强制杀死...');
|
||
try {
|
||
// 【Windows 专用】使用 taskkill 强制杀死所有 sing-box 进程
|
||
// ✅ 使用 KRWindowsProcessUtil.runHidden 避免黑窗
|
||
if (Platform.isWindows) {
|
||
final result = await KRWindowsProcessUtil.runHidden(
|
||
'taskkill',
|
||
['/IM', 'sing-box.exe', '/F'],
|
||
);
|
||
|
||
// 【关键】检查返回码！
|
||
if (result.exitCode == 0) {
|
||
await KRFileLogger.log('[进程恢复] ✅ taskkill 成功（返回码: 0）');
|
||
killSucceeded = true;
|
||
} else {
|
||
await KRFileLogger.log('[进程恢复] ⚠️ taskkill 返回码: ${result.exitCode}（可能失败）');
|
||
// 返回码 128 = 进程未找到（可能已自动退出）
|
||
// 返回码 1 = 没有权限
|
||
killSucceeded = (result.exitCode == 128); // 128 = 进程已不存在（正常）
|
||
}
|
||
} else {
|
||
// 【非 Windows 平台】跳过 taskkill，仅依赖优雅关闭
|
||
await KRFileLogger.log('[进程恢复] ℹ️ 非 Windows 平台，跳过 taskkill，依赖优雅关闭');
|
||
killSucceeded = true; // 假设优雅关闭足够
|
||
}
|
||
} catch (e) {
|
||
await KRFileLogger.log('[进程恢复] ⚠️ taskkill 执行异常: $e');
|
||
killSucceeded = false;
|
||
}
|
||
|
||
// 5️⃣ 等待进程资源完全释放
|
||
// 如果 kill 成功，等待较短的时间；如果失败，等待较长的时间
|
||
final waitDuration = killSucceeded
|
||
? const Duration(milliseconds: 500)
|
||
: const Duration(milliseconds: 1000);
|
||
await Future.delayed(waitDuration);
|
||
}
|
||
|
||
// 6️⃣ 轮询等待端口完全释放（避免 TIME_WAIT 状态）
|
||
await KRFileLogger.log('[进程恢复] 🔍 轮询验证 8964 端口是否完全释放...');
|
||
int releaseRetries = 0;
|
||
const maxReleaseRetries = 20; // 最多等待 10 秒
|
||
bool portFullyReleased = false;
|
||
|
||
while (releaseRetries < maxReleaseRetries) {
|
||
try {
|
||
// 尝试连接，如果失败说明端口已释放
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 100),
|
||
onTimeout: () => throw Exception('端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
|
||
// 仍然能连接，继续等待
|
||
releaseRetries++;
|
||
final elapsedMs = releaseRetries * 500;
|
||
await KRFileLogger.log('[进程恢复] ⏳ 端口仍被占用，等待中... (#$releaseRetries, 已等待 ${elapsedMs}ms)');
|
||
|
||
// 如果等待超过 5 秒且端口仍被占用，说明有其他进程占用端口（异常）
|
||
if (elapsedMs > 5000 && releaseRetries % 4 == 0) {
|
||
await KRFileLogger.log('[进程恢复] ⚠️ 【警告】端口占用超过 5 秒，可能有其他进程占用！');
|
||
}
|
||
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
} catch (e) {
|
||
// 无法连接，端口已释放
|
||
portFullyReleased = true;
|
||
final elapsedMs = releaseRetries * 500;
|
||
await KRFileLogger.log('[进程恢复] ✅ 确认 8964 端口已完全释放（耗时 ${elapsedMs}ms）');
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!portFullyReleased) {
|
||
await KRFileLogger.log('[进程恢复] ⚠️ 等待端口释放超时（已等待 ${maxReleaseRetries * 500}ms），继续尝试重启...');
|
||
}
|
||
|
||
// 7️⃣ 重新启动 sing-box（带重试）
|
||
await KRFileLogger.log('[进程恢复] 🟡 准备重新启动 sing-box...');
|
||
int startRetries = 0;
|
||
const maxStartRetries = 3;
|
||
bool startSucceeded = false;
|
||
|
||
while (startRetries < maxStartRetries) {
|
||
try {
|
||
await kr_singBox.start(_cutPath, kr_configName, false).map(
|
||
(r) {
|
||
KRLogUtil.kr_i('✅ sing-box 恢复启动成功', tag: 'ProcessMonitor');
|
||
return r;
|
||
},
|
||
).mapLeft((err) {
|
||
KRLogUtil.kr_e('❌ sing-box 恢复启动失败: $err', tag: 'ProcessMonitor');
|
||
throw err;
|
||
}).run();
|
||
|
||
startSucceeded = true;
|
||
await KRFileLogger.log('[进程恢复] ✅ sing-box 进程已恢复启动（第 ${startRetries + 1} 次尝试）');
|
||
break;
|
||
} catch (e) {
|
||
startRetries++;
|
||
await KRFileLogger.log('[进程恢复] ❌ sing-box 启动失败（第 $startRetries 次，错误：$e）');
|
||
|
||
if (startRetries < maxStartRetries) {
|
||
// 启动失败，增加延迟后重试
|
||
final delayMs = 1000 + (startRetries * 1000); // 1s, 2s, 3s 递增延迟
|
||
await KRFileLogger.log('[进程恢复] ⏳ 将在 ${delayMs}ms 后进行第 ${startRetries + 1} 次尝试...');
|
||
await Future.delayed(Duration(milliseconds: delayMs));
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!startSucceeded) {
|
||
await KRFileLogger.log('[进程恢复] ❌ sing-box 恢复启动失败（3 次尝试都失败）');
|
||
throw Exception('sing-box 恢复启动失败');
|
||
}
|
||
|
||
// 8️⃣ 启动后等待 sing-box 真正准备好
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
|
||
// 验证 8964 端口真的可以连接
|
||
int portCheckRetries = 0;
|
||
while (portCheckRetries < 5) {
|
||
try {
|
||
final socket = await Socket.connect('127.0.0.1', 8964).timeout(
|
||
const Duration(milliseconds: 200),
|
||
onTimeout: () => throw Exception('端口连接超时'),
|
||
);
|
||
socket.destroy();
|
||
await KRFileLogger.log('[进程恢复] ✅ 8964 端口已准备好，sing-box 完全就绪');
|
||
break;
|
||
} catch (e) {
|
||
portCheckRetries++;
|
||
if (portCheckRetries < 5) {
|
||
await Future.delayed(const Duration(milliseconds: 200));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 9️⃣ 重新开始监测
|
||
unawaited(_monitorSingBoxProcess());
|
||
|
||
} catch (e) {
|
||
await KRFileLogger.log('[进程恢复] ❌ 进程恢复失败: $e');
|
||
KRLogUtil.kr_e('进程恢复失败: $e', tag: 'ProcessMonitor');
|
||
}
|
||
}
|
||
|
||
/// FFI 实现：直接调用 Windows IsUserAnAdmin() API
|
||
/// 返回 true 表示有管理员权限，false 表示无权限
|
||
///
|
||
/// ✅ 优点：
|
||
/// - 不创建新进程，无黑屏
|
||
/// - 直接 API 调用，超快速（1-5ms）
|
||
/// - 内存操作，零 I/O 等待
|
||
/// - Windows 官方 API，完全可靠
|
||
bool _isUserAnAdminFFI() {
|
||
try {
|
||
// 加载 shell32.dll（包含 IsUserAnAdmin 函数）
|
||
final shell32 = DynamicLibrary.open('shell32.dll');
|
||
|
||
// 定义 FFI 绑定
|
||
// IsUserAnAdmin 返回 BOOL（Uint8 in Dart），无参数
|
||
final isUserAnAdmin = shell32.lookupFunction<
|
||
Uint8 Function(),
|
||
int Function()
|
||
>('IsUserAnAdmin');
|
||
|
||
// 调用 API 并检查返回值
|
||
// 返回值 != 0 表示是管理员，== 0 表示不是
|
||
final result = isUserAnAdmin();
|
||
return result != 0;
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ FFI 权限检查异常: $e', tag: 'SingBox');
|
||
// 异常时返回 false，安全起见假设无权限
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// ==================== macOS SOCKS5 系统代理 ====================
|
||
// 🍎 让 Telegram 等应用自动走代理（参考 Clash 实现）
|
||
// 原因：libcore 只设置 HTTP/HTTPS 代理，但 Telegram 只检测 SOCKS5 代理
|
||
|
||
/// 获取当前活动的网络服务名称（Wi-Fi、Ethernet 等）
|
||
Future<String?> _kr_getMacOSActiveNetworkService() async {
|
||
if (!Platform.isMacOS) return null;
|
||
|
||
try {
|
||
// 获取默认路由的网络接口
|
||
final routeResult = await Process.run('route', ['-n', 'get', 'default']);
|
||
if (routeResult.exitCode != 0) {
|
||
KRLogUtil.kr_w('⚠️ 获取默认路由失败', tag: 'SingBox');
|
||
return 'Wi-Fi'; // 默认返回 Wi-Fi
|
||
}
|
||
|
||
final routeOutput = routeResult.stdout.toString();
|
||
final interfaceMatch = RegExp(r'interface:\s*(\S+)').firstMatch(routeOutput);
|
||
if (interfaceMatch == null) {
|
||
return 'Wi-Fi';
|
||
}
|
||
|
||
final interfaceName = interfaceMatch.group(1);
|
||
KRLogUtil.kr_i('🔍 检测到网络接口: $interfaceName', tag: 'SingBox');
|
||
|
||
// 获取网络服务列表，找到对应的服务名称
|
||
final servicesResult = await Process.run('networksetup', ['-listallhardwareports']);
|
||
if (servicesResult.exitCode != 0) {
|
||
return 'Wi-Fi';
|
||
}
|
||
|
||
final servicesOutput = servicesResult.stdout.toString();
|
||
final lines = servicesOutput.split('\n');
|
||
|
||
String? currentService;
|
||
for (final line in lines) {
|
||
if (line.startsWith('Hardware Port:')) {
|
||
currentService = line.replaceFirst('Hardware Port:', '').trim();
|
||
} else if (line.startsWith('Device:') && currentService != null) {
|
||
final device = line.replaceFirst('Device:', '').trim();
|
||
if (device == interfaceName) {
|
||
KRLogUtil.kr_i('✅ 找到网络服务: $currentService', tag: 'SingBox');
|
||
return currentService;
|
||
}
|
||
}
|
||
}
|
||
|
||
return 'Wi-Fi'; // 默认返回 Wi-Fi
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 获取网络服务失败: $e', tag: 'SingBox');
|
||
return 'Wi-Fi';
|
||
}
|
||
}
|
||
|
||
/// 设置或清除 macOS SOCKS5 系统代理
|
||
/// [enable] true=设置代理, false=清除代理
|
||
Future<void> _kr_setMacOSSocks5Proxy(bool enable) async {
|
||
if (!Platform.isMacOS) return;
|
||
|
||
try {
|
||
final networkService = await _kr_getMacOSActiveNetworkService();
|
||
if (networkService == null) {
|
||
KRLogUtil.kr_w('⚠️ 无法获取网络服务名称', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
if (enable) {
|
||
// 设置 SOCKS5 代理（参考 Clash 实现）
|
||
KRLogUtil.kr_i('🍎 设置 macOS SOCKS5 系统代理: $networkService → 127.0.0.1:$kr_port', tag: 'SingBox');
|
||
|
||
// 设置 SOCKS 代理服务器和端口
|
||
final setResult = await Process.run('networksetup', [
|
||
'-setsocksfirewallproxy',
|
||
networkService,
|
||
'127.0.0.1',
|
||
kr_port.toString(),
|
||
]);
|
||
|
||
if (setResult.exitCode != 0) {
|
||
KRLogUtil.kr_e('❌ 设置 SOCKS5 代理失败: ${setResult.stderr}', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
// 启用 SOCKS 代理
|
||
final enableResult = await Process.run('networksetup', [
|
||
'-setsocksfirewallproxystate',
|
||
networkService,
|
||
'on',
|
||
]);
|
||
|
||
if (enableResult.exitCode != 0) {
|
||
KRLogUtil.kr_e('❌ 启用 SOCKS5 代理失败: ${enableResult.stderr}', tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ macOS SOCKS5 系统代理已设置（Telegram 等应用将自动走代理）', tag: 'SingBox');
|
||
|
||
} else {
|
||
// 清除 SOCKS5 代理
|
||
KRLogUtil.kr_i('🍎 清除 macOS SOCKS5 系统代理: $networkService', tag: 'SingBox');
|
||
|
||
// 禁用 SOCKS 代理
|
||
final disableResult = await Process.run('networksetup', [
|
||
'-setsocksfirewallproxystate',
|
||
networkService,
|
||
'off',
|
||
]);
|
||
|
||
if (disableResult.exitCode != 0) {
|
||
KRLogUtil.kr_w('⚠️ 禁用 SOCKS5 代理失败: ${disableResult.stderr}', tag: 'SingBox');
|
||
} else {
|
||
KRLogUtil.kr_i('✅ macOS SOCKS5 系统代理已清除', tag: 'SingBox');
|
||
}
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ macOS SOCKS5 代理操作异常: $e', tag: 'SingBox');
|
||
}
|
||
}
|
||
}
|
||
|
||
// 🔧 _KRWindowsProxySnapshot 类已删除 - 改用 WinINet API 直接操作，无需快照对象
|