2066 lines
77 KiB
Dart
Executable File
2066 lines
77 KiB
Dart
Executable File
import 'dart:convert';
|
||
import 'dart:io';
|
||
import 'dart:async';
|
||
|
||
import 'package:flutter/services.dart';
|
||
import 'package:fpdart/fpdart.dart';
|
||
import 'package:get/get.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_secure_storage.dart';
|
||
import '../../utils/kr_windows_dns_util.dart';
|
||
import '../../common/app_run_data.dart';
|
||
import 'package:flutter/foundation.dart';
|
||
|
||
enum KRConnectionType {
|
||
global,
|
||
rule,
|
||
// direct,
|
||
}
|
||
|
||
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;
|
||
|
||
/// 统计
|
||
final kr_stats = SingboxStats(
|
||
connectionsIn: 0,
|
||
connectionsOut: 0,
|
||
uplink: 0,
|
||
downlink: 0,
|
||
uplinkTotal: 0,
|
||
downlinkTotal: 0,
|
||
).obs;
|
||
|
||
/// 活动的出站分组
|
||
RxList<SingboxOutboundGroup> kr_activeGroups = <SingboxOutboundGroup>[].obs;
|
||
|
||
// 🔒 Windows DNS 优化：标志位，记录 DNS 是否已备份
|
||
bool _dnsBackedUp = false;
|
||
|
||
/// 所有的出站分组
|
||
RxList<SingboxOutboundGroup> kr_allGroups = <SingboxOutboundGroup>[].obs;
|
||
|
||
/// Stream 订阅管理器
|
||
final List<StreamSubscription<dynamic>> _kr_subscriptions = [];
|
||
|
||
/// 初始化标志，防止重复初始化
|
||
bool _kr_isInitialized = false;
|
||
|
||
/// 初始化进行中共享 Future（single-flight 防并发）
|
||
Future<void>? _kr_initFuture;
|
||
|
||
/// 当前混合代理端口是否就绪
|
||
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 = true}) {
|
||
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;
|
||
}
|
||
|
||
// 防止并发重复初始化（进行中复用同一个 Future）
|
||
if (_kr_initFuture != null) {
|
||
KRLogUtil.kr_i('SingBox 初始化进行中，等待完成（single-flight）', tag: 'SingBox');
|
||
await _kr_initFuture;
|
||
return;
|
||
}
|
||
|
||
// 建立 single-flight 共享 Future
|
||
final completer = Completer<void>();
|
||
_kr_initFuture = completer.future;
|
||
|
||
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 发送消息
|
||
KRLogUtil.kr_i('📡 开始调用 setup() 注册 FFI 端口', tag: 'SingBox');
|
||
final setupResult = await kr_singBox.setup(kr_configDics, false).run();
|
||
setupResult.match(
|
||
(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();
|
||
KRLogUtil.kr_i('✅ 状态订阅已设置', tag: 'SingBox');
|
||
|
||
// 完成 single-flight
|
||
completer.complete();
|
||
_kr_initFuture = null;
|
||
} 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;
|
||
// 失败时通知等待者并清理 single-flight
|
||
if (!completer.isCompleted) {
|
||
completer.completeError(e, stackTrace);
|
||
}
|
||
_kr_initFuture = null;
|
||
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 op = {
|
||
"region": effectiveRegion, // 🔧 修复：根据出站模式动态设置 region
|
||
"block-ads": false, // 参考 hiddify-app: 默认关闭广告拦截
|
||
"use-xray-core-when-possible": false,
|
||
"execute-config-as-is": true, // 🔧 修复：使用我们生成的完整配置，不让 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":
|
||
"https://dns.google/dns-query", // 使用 Google DoH，避免中转节点 DNS 死锁
|
||
"remote-dns-domain-strategy": "prefer_ipv4",
|
||
"direct-dns-address": "local", // 使用系统 DNS，确保中转服务器域名能被解析
|
||
"direct-dns-domain-strategy": "prefer_ipv4",
|
||
"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,
|
||
"enable-tun": Platform.isIOS || Platform.isAndroid,
|
||
"enable-tun-service": false,
|
||
"set-system-proxy":
|
||
Platform.isWindows || Platform.isLinux || Platform.isMacOS,
|
||
"bypass-lan": false,
|
||
"allow-connection-from-lan": false,
|
||
"enable-fake-dns": false,
|
||
"enable-dns-routing": true,
|
||
"independent-dns-cache": true,
|
||
"rules": _kr_buildHiddifyRules(),
|
||
"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) {
|
||
print('🔵 _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) {
|
||
print('🔵 已取消旧的状态订阅');
|
||
}
|
||
}
|
||
}
|
||
_kr_subscriptions
|
||
.removeWhere((sub) => sub.hashCode.toString().contains('Status'));
|
||
|
||
_kr_subscriptions.add(
|
||
kr_singBox.watchStatus().listen(
|
||
(status) {
|
||
if (kDebugMode) {
|
||
print('🔵 收到 Native 状态更新: ${status.runtimeType}');
|
||
}
|
||
KRLogUtil.kr_i('📡 收到状态更新: $status', tag: 'SingBox');
|
||
kr_status.value = status;
|
||
},
|
||
onError: (error) {
|
||
if (kDebugMode) {
|
||
print('🔵 状态流错误: $error');
|
||
}
|
||
KRLogUtil.kr_e('📡 状态流错误: $error', tag: 'SingBox');
|
||
},
|
||
cancelOnError: false,
|
||
),
|
||
);
|
||
|
||
if (kDebugMode) {
|
||
print('🔵 状态流订阅完成');
|
||
}
|
||
}
|
||
|
||
/// 订阅统计数据流
|
||
void _kr_subscribeToStats() {
|
||
// 取消之前的统计订阅
|
||
for (var sub in _kr_subscriptions) {
|
||
if (sub.hashCode.toString().contains('Stats')) {
|
||
sub.cancel();
|
||
}
|
||
}
|
||
_kr_subscriptions
|
||
.removeWhere((sub) => sub.hashCode.toString().contains('Stats'));
|
||
|
||
// ⚠️ 关键：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,
|
||
);
|
||
_kr_subscriptions.add(subscription);
|
||
}
|
||
|
||
/// 订阅分组数据流
|
||
void _kr_subscribeToGroups() {
|
||
print('[_kr_subscribeToGroups] 🚀 开始订阅分组数据流');
|
||
// 取消之前的分组订阅
|
||
for (var sub in _kr_subscriptions) {
|
||
if (sub.hashCode.toString().contains('Groups')) {
|
||
sub.cancel();
|
||
}
|
||
}
|
||
_kr_subscriptions
|
||
.removeWhere((sub) => sub.hashCode.toString().contains('Groups'));
|
||
|
||
_kr_subscriptions.add(
|
||
kr_singBox.watchActiveGroups().listen(
|
||
(groups) {
|
||
print('[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) {
|
||
print('[watchActiveGroups] ❌ 活动分组监听错误: $error');
|
||
KRLogUtil.kr_e('❌ 活动分组监听错误: $error', tag: 'SingBox');
|
||
},
|
||
cancelOnError: false,
|
||
),
|
||
);
|
||
|
||
_kr_subscriptions.add(
|
||
kr_singBox.watchGroups().listen(
|
||
(groups) {
|
||
print('[watchGroups] 📡 收到所有组更新，数量: ${groups.length}');
|
||
kr_allGroups.value = groups;
|
||
// 打印每个组的基本信息
|
||
for (int i = 0; i < groups.length; i++) {
|
||
final group = groups[i];
|
||
print(
|
||
'[watchGroups] 组[$i]: tag=${group.tag}, type=${group.type}, selected=${group.selected}');
|
||
}
|
||
},
|
||
onError: (error) {
|
||
print('[watchGroups] ❌ 所有分组监听错误: $error');
|
||
KRLogUtil.kr_e('所有分组监听错误: $error');
|
||
},
|
||
cancelOnError: false,
|
||
),
|
||
);
|
||
print(
|
||
'[_kr_subscribeToGroups] ✅ 分组数据流订阅完成，当前订阅数: ${_kr_subscriptions.length}');
|
||
}
|
||
|
||
/// 验证节点选择是否生效
|
||
///
|
||
/// 检查活动组中 "select" 组的 selected 字段是否是目标节点
|
||
Future<void> _kr_verifyNodeSelection(String targetTag) async {
|
||
try {
|
||
KRLogUtil.kr_i('🔍 开始验证节点选择: $targetTag', tag: 'SingBox');
|
||
|
||
// 查找 "select" 组
|
||
final selectGroup = kr_activeGroups.firstWhere(
|
||
(group) => group.tag == 'select',
|
||
orElse: () => throw Exception('未找到 "select" 选择器组'),
|
||
);
|
||
|
||
KRLogUtil.kr_i('📊 Select 组状态:', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - 组标签: ${selectGroup.tag}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - 组类型: ${selectGroup.type}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - 当前选中: ${selectGroup.selected}', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - 目标节点: $targetTag', tag: 'SingBox');
|
||
KRLogUtil.kr_i(' - 可用节点数: ${selectGroup.items.length}', tag: 'SingBox');
|
||
|
||
// 验证目标节点是否在可用列表中
|
||
final hasTarget = selectGroup.items.any((item) => item.tag == targetTag);
|
||
if (!hasTarget) {
|
||
KRLogUtil.kr_w('⚠️ 目标节点不在 select 组的可用列表中: $targetTag', tag: 'SingBox');
|
||
KRLogUtil.kr_w('可用节点列表:', tag: 'SingBox');
|
||
for (var item in selectGroup.items) {
|
||
KRLogUtil.kr_w(' - ${item.tag}', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
// 检查是否切换成功
|
||
if (selectGroup.selected != targetTag) {
|
||
KRLogUtil.kr_e('❌ 节点切换验证失败！', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - 期望: $targetTag', tag: 'SingBox');
|
||
KRLogUtil.kr_e(' - 实际: ${selectGroup.selected}', tag: 'SingBox');
|
||
throw Exception('节点切换失败：实际选中 ${selectGroup.selected}，期望 $targetTag');
|
||
}
|
||
|
||
KRLogUtil.kr_i('✅ 节点切换验证成功: ${selectGroup.selected} == $targetTag',
|
||
tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 节点验证异常: $e', 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;
|
||
|
||
// ⚠️ 关键修复：使用 Future.delayed(Duration.zero) 将订阅推到下一个事件循环
|
||
// 这样可以避免阻塞当前的异步执行
|
||
try {
|
||
KRLogUtil.kr_i('📊 订阅统计数据流...', tag: 'SingBox');
|
||
await Future.delayed(Duration.zero); // 让出 UI 线程
|
||
_kr_subscribeToStats();
|
||
statsSubscribed = true;
|
||
KRLogUtil.kr_i('✅ 统计数据流订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 统计数据流订阅失败: $e', tag: 'SingBox');
|
||
}
|
||
|
||
try {
|
||
KRLogUtil.kr_i('📋 订阅分组数据流...', tag: 'SingBox');
|
||
await Future.delayed(Duration.zero); // 让出 UI 线程
|
||
_kr_subscribeToGroups();
|
||
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 调用时会重新尝试
|
||
try {
|
||
_kr_subscribeToStats();
|
||
KRLogUtil.kr_i('✅ 统计流预订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 统计流预订阅失败（正常，UI 调用时会重试）: $e', tag: 'SingBox');
|
||
}
|
||
|
||
try {
|
||
_kr_subscribeToGroups();
|
||
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 {
|
||
// 如果已经有订阅,说明 command client 已初始化
|
||
if (_kr_subscriptions.isNotEmpty) {
|
||
KRLogUtil.kr_i('✅ Command client 已初始化（订阅数: ${_kr_subscriptions.length}）',
|
||
tag: 'SingBox');
|
||
return;
|
||
}
|
||
|
||
KRLogUtil.kr_i('⚠️ Command client 未初始化,触发订阅...', tag: 'SingBox');
|
||
|
||
try {
|
||
// 触发 watchGroups(),这会自动调用 startCommandClient()
|
||
_kr_subscribeToGroups();
|
||
|
||
// 等待一小段时间让订阅建立
|
||
await Future.delayed(const Duration(milliseconds: 300));
|
||
|
||
if (_kr_subscriptions.isEmpty) {
|
||
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['interval'] != null) {
|
||
KRLogUtil.kr_i(' - interval: ${outbound['interval']}', 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');
|
||
|
||
// 🔧 修复：生成完整的 SingBox 配置
|
||
// 之前只保存 {"outbounds": [...]}, 导致 libcore 无法正确处理
|
||
// 现在保存完整配置，包含所有必需字段
|
||
final Map<String, dynamic> fullConfig = {
|
||
"log": {"level": "debug", "timestamp": true},
|
||
"dns": {
|
||
"servers": [
|
||
{
|
||
"tag": "dns-remote",
|
||
"address": "https://1.1.1.1/dns-query",
|
||
"address_resolver": "dns-direct"
|
||
},
|
||
{"tag": "dns-direct", "address": "local", "detour": "direct"}
|
||
],
|
||
"rules": _kr_buildDnsRules(), // ✅ 使用动态构建的 DNS 规则
|
||
"final": "dns-remote",
|
||
"strategy": "prefer_ipv4"
|
||
},
|
||
"inbounds": [
|
||
{
|
||
"type": "tun",
|
||
"tag": "tun-in",
|
||
"interface_name": "utun",
|
||
"inet4_address": "172.19.0.1/30",
|
||
"auto_route": true,
|
||
"strict_route": true,
|
||
"sniff": true,
|
||
"sniff_override_destination": false
|
||
}
|
||
],
|
||
"outbounds": [
|
||
// 🔧 修复：添加 selector 组，让用户可以手动选择节点
|
||
{
|
||
"type": "selector",
|
||
"tag": "proxy",
|
||
"outbounds": kr_outbounds.map((o) => o['tag'] as String).toList(),
|
||
"default":
|
||
kr_outbounds.isNotEmpty ? kr_outbounds[0]['tag'] : "direct",
|
||
},
|
||
...kr_outbounds,
|
||
{"type": "direct", "tag": "direct"},
|
||
{"type": "block", "tag": "block"},
|
||
{"type": "dns", "tag": "dns-out"}
|
||
],
|
||
"route": {
|
||
"rules": _kr_buildRouteRules(), // ✅ 使用动态构建的路由规则
|
||
"rule_set": _kr_buildRuleSets(), // ✅ 使用动态构建的规则集
|
||
"final": "proxy", // 🔧 修复：使用 selector 组作为默认出站
|
||
"auto_detect_interface": true
|
||
}
|
||
};
|
||
|
||
final file = _file(kr_configName);
|
||
final temp = _tempFile(kr_configName);
|
||
final mapStr = jsonEncode(fullConfig);
|
||
|
||
KRLogUtil.kr_i('📄 完整配置文件长度: ${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');
|
||
|
||
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"});
|
||
|
||
// ✅ 自定义域名直连规则（优先级高，放在前面）
|
||
// rules.add({
|
||
// "domain_suffix": ["ip138.com"],
|
||
// "outbound": "direct"
|
||
// });
|
||
|
||
// KRLogUtil.kr_i('✅ 添加自定义域名直连规则: ip138.com -> direct', tag: 'SingBox');
|
||
|
||
// 🔧 关键修复：只有在"智能代理"模式下，才根据国家添加直连规则
|
||
// 如果是"全局代理"模式，即使选择了国家也不添加直连规则
|
||
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 {
|
||
// 不再手动设置状态，libcore 会通过 status stream 自动发送状态更新
|
||
try {
|
||
// 🔧 修复3: 添加登录状态检查 - 只有已登录用户才能连接VPN
|
||
if (!KRAppRunData().kr_isLogin.value) {
|
||
KRLogUtil.kr_e('❌ 未登录用户，禁止启动VPN连接', tag: 'SingBox');
|
||
throw Exception('用户未登录，无法启动VPN服务');
|
||
}
|
||
|
||
// ⚠️ 强制编译标记 - 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');
|
||
|
||
// 🔑 Windows 平台：仅在首次启动时备份 DNS 设置（优化：避免重复备份）
|
||
if (Platform.isWindows && !_dnsBackedUp) {
|
||
KRLogUtil.kr_i('🪟 Windows 平台，首次启动备份 DNS 设置...', tag: 'SingBox');
|
||
try {
|
||
final backupSuccess =
|
||
await KRWindowsDnsUtil.instance.kr_backupDnsSettings();
|
||
if (backupSuccess) {
|
||
_dnsBackedUp = true; // 标记已备份
|
||
KRLogUtil.kr_i('✅ Windows DNS 备份成功', tag: 'SingBox');
|
||
} else {
|
||
KRLogUtil.kr_w('⚠️ Windows DNS 备份失败，将在停止时使用兜底恢复', tag: 'SingBox');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ Windows DNS 备份异常: $e，将在停止时使用兜底恢复', tag: 'SingBox');
|
||
}
|
||
} else if (Platform.isWindows && _dnsBackedUp) {
|
||
KRLogUtil.kr_i('⏭️ Windows 平台，DNS 已备份，跳过重复备份（节点切换优化）', tag: 'SingBox');
|
||
}
|
||
|
||
// 🔑 先尝试停止旧实例，避免 command.sock 冲突
|
||
// 注意：如果没有旧实例，libcore 会报错 "command.sock: no such file"，这是正常的
|
||
try {
|
||
await kr_singBox.stop().run();
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
KRLogUtil.kr_i('✅ 已清理旧实例', tag: 'SingBox');
|
||
} catch (e) {
|
||
// 预期行为：没有旧实例时会报错，可以忽略
|
||
KRLogUtil.kr_i('ℹ️ 没有运行中的旧实例（正常）', tag: 'SingBox');
|
||
}
|
||
|
||
// 🔑 关键步骤：在 start 之前必须调用 changeOptions 初始化 HiddifyOptions
|
||
// 否则 libcore 的 StartService 会因为 HiddifyOptions == nil 而 panic
|
||
KRLogUtil.kr_i('📡 初始化 HiddifyOptions...', tag: 'SingBox');
|
||
final oOption = SingboxConfigOption.fromJson(_getConfigOption());
|
||
final changeResult = await kr_singBox.changeOptions(oOption).run();
|
||
changeResult.match(
|
||
(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 kr_singBox.start(_cutPath, kr_configName, false).map(
|
||
(r) {
|
||
KRLogUtil.kr_i('✅ SingBox 启动成功', tag: 'SingBox');
|
||
},
|
||
).mapLeft((err) {
|
||
KRLogUtil.kr_e('❌ SingBox 启动失败: $err', tag: 'SingBox');
|
||
// 不需要手动设置状态，libcore 会通过 status stream 自动发送 Stopped 事件
|
||
throw err;
|
||
}).run();
|
||
|
||
// ⚠️ 关键修复：在启动成功后立即订阅统计流
|
||
// 原因：
|
||
// 1. 统计流需要主动订阅才能接收数据
|
||
// 2. UI 只是读取 kr_stats.value，不会触发订阅
|
||
// 3. command.sock 在 start() 成功后会立即创建
|
||
|
||
KRLogUtil.kr_i('✅ SingBox 核心已启动，开始初始化 command client', tag: 'SingBox');
|
||
|
||
// 🔑 在后台延迟订阅统计流和分组流，避免阻塞 UI
|
||
Future.delayed(const Duration(milliseconds: 1000), () async {
|
||
try {
|
||
KRLogUtil.kr_i('📊 开始订阅统计数据流...', tag: 'SingBox');
|
||
_kr_subscribeToStats();
|
||
KRLogUtil.kr_i('✅ 统计数据流订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 统计数据流订阅失败（稍后重试）: $e', tag: 'SingBox');
|
||
// 如果第一次失败，再等待一段时间重试
|
||
Future.delayed(const Duration(milliseconds: 2000), () {
|
||
try {
|
||
_kr_subscribeToStats();
|
||
KRLogUtil.kr_i('✅ 统计数据流重试订阅成功', tag: 'SingBox');
|
||
} catch (e2) {
|
||
KRLogUtil.kr_e('❌ 统计数据流重试订阅失败: $e2', tag: 'SingBox');
|
||
}
|
||
});
|
||
}
|
||
|
||
// 🔧 关键修复：订阅分组数据流
|
||
try {
|
||
KRLogUtil.kr_i('📋 开始订阅分组数据流...', tag: 'SingBox');
|
||
_kr_subscribeToGroups();
|
||
KRLogUtil.kr_i('✅ 分组数据流订阅成功', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 分组数据流订阅失败（稍后重试）: $e', tag: 'SingBox');
|
||
// 如果第一次失败，再等待一段时间重试
|
||
Future.delayed(const Duration(milliseconds: 2000), () {
|
||
try {
|
||
_kr_subscribeToGroups();
|
||
KRLogUtil.kr_i('✅ 分组数据流重试订阅成功', tag: 'SingBox');
|
||
} catch (e2) {
|
||
KRLogUtil.kr_e('❌ 分组数据流重试订阅失败: $e2', tag: 'SingBox');
|
||
}
|
||
});
|
||
}
|
||
|
||
// 🔧 关键修复：恢复用户选择的节点
|
||
try {
|
||
final selectedNode =
|
||
await KRSecureStorage().kr_readData(key: _keySelectedNode);
|
||
if (selectedNode != null && selectedNode.isNotEmpty) {
|
||
KRLogUtil.kr_i('🎯 恢复用户选择的节点: $selectedNode', tag: 'SingBox');
|
||
if (kDebugMode) {
|
||
print('🔵 启动后恢复节点选择: $selectedNode');
|
||
}
|
||
|
||
// 延迟500ms确保sing-box完全启动
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
|
||
// 🔧 关键修复：使用 await 等待节点切换完成
|
||
try {
|
||
await kr_selectOutbound(selectedNode);
|
||
KRLogUtil.kr_i('✅ 节点已切换到用户选择: $selectedNode', tag: 'SingBox');
|
||
if (kDebugMode) {
|
||
print('🔵 节点切换成功: $selectedNode');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 节点切换失败: $e', tag: 'SingBox');
|
||
if (kDebugMode) {
|
||
print('🔵 节点切换失败: $e');
|
||
}
|
||
}
|
||
} else {
|
||
KRLogUtil.kr_i('ℹ️ 没有保存的节点选择，使用默认配置', tag: 'SingBox');
|
||
if (kDebugMode) {
|
||
print('🔵 没有保存的节点选择，使用默认');
|
||
}
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 恢复节点选择失败: $e', tag: 'SingBox');
|
||
if (kDebugMode) {
|
||
print('🔵 恢复节点选择失败: $e');
|
||
}
|
||
}
|
||
});
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('💥 SingBox 启动异常: $e', tag: 'SingBox');
|
||
KRLogUtil.kr_e('📚 错误堆栈: $stackTrace', tag: 'SingBox');
|
||
// 不需要手动设置状态，libcore 会自动处理
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
/// 停止服务
|
||
Future<void> kr_stop() async {
|
||
try {
|
||
KRLogUtil.kr_i('🛑 停止 SingBox 服务...', tag: 'SingBox');
|
||
|
||
// 取消节点选择监控定时器
|
||
_nodeSelectionTimer?.cancel();
|
||
_nodeSelectionTimer = null;
|
||
KRLogUtil.kr_i('✅ 节点选择监控已停止', tag: 'SingBox');
|
||
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
|
||
// 添加超时保护,防止 stop() 调用阻塞
|
||
// 🔧 延长超时时间到 10 秒，给 Windows DNS 清理足够时间
|
||
try {
|
||
await kr_singBox.stop().run().timeout(
|
||
const Duration(seconds: 10), // ← 从 3 秒延长到 10 秒
|
||
onTimeout: () {
|
||
KRLogUtil.kr_w('⚠️ 停止操作超时(10秒)，强制继续', tag: 'SingBox');
|
||
return const Left('timeout');
|
||
},
|
||
);
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 停止操作失败（可能已经停止）: $e', tag: 'SingBox');
|
||
// 继续执行清理操作
|
||
}
|
||
|
||
// 🔑 Windows 平台：仅在有备份时恢复 DNS 设置
|
||
if (Platform.isWindows && _dnsBackedUp) {
|
||
KRLogUtil.kr_i('🪟 Windows 平台，等待 sing-box 完全停止...', tag: 'SingBox');
|
||
|
||
// 🔧 P3优化: 监听状态而非固定延迟，确保 sing-box 真正停止后再恢复 DNS
|
||
try {
|
||
// 如果当前已经是停止状态，直接继续
|
||
if (kr_status.value is SingboxStopped) {
|
||
KRLogUtil.kr_i('✅ sing-box 已经是停止状态，立即恢复 DNS', tag: 'SingBox');
|
||
} else {
|
||
// 等待状态变为停止，最多等待3秒
|
||
final completer = Completer<void>();
|
||
late final Worker worker;
|
||
|
||
worker = ever(kr_status, (status) {
|
||
if (status is SingboxStopped) {
|
||
if (!completer.isCompleted) {
|
||
completer.complete();
|
||
worker.dispose();
|
||
}
|
||
}
|
||
});
|
||
|
||
await completer.future.timeout(
|
||
const Duration(seconds: 3),
|
||
onTimeout: () {
|
||
KRLogUtil.kr_w('⏱️ 等待停止状态超时，继续执行 DNS 恢复', tag: 'SingBox');
|
||
worker.dispose();
|
||
},
|
||
);
|
||
|
||
KRLogUtil.kr_i('✅ sing-box 已完全停止，开始恢复 DNS...', tag: 'SingBox');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_w('⚠️ 状态监听异常: $e，继续执行 DNS 恢复', tag: 'SingBox');
|
||
}
|
||
|
||
try {
|
||
// 尝试恢复 DNS
|
||
final restoreSuccess =
|
||
await KRWindowsDnsUtil.instance.kr_restoreDnsSettings();
|
||
if (restoreSuccess) {
|
||
KRLogUtil.kr_i('✅ Windows DNS 恢复成功', tag: 'SingBox');
|
||
} else {
|
||
KRLogUtil.kr_e('❌ Windows DNS 恢复失败', tag: 'SingBox');
|
||
}
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ Windows DNS 恢复异常: $e', tag: 'SingBox');
|
||
// 异常时也会在工具类内部执行兜底恢复
|
||
} finally {
|
||
// 🔧 P0修复2: 使用 finally 确保标志位始终被重置，避免下次启动跳过备份
|
||
_dnsBackedUp = false;
|
||
KRLogUtil.kr_i('🔄 重置 DNS 备份标志位', tag: 'SingBox');
|
||
}
|
||
} else if (Platform.isWindows && !_dnsBackedUp) {
|
||
KRLogUtil.kr_i('⏭️ Windows 平台，DNS 未备份，跳过恢复', tag: 'SingBox');
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
} else {
|
||
// 非 Windows 平台正常等待
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
}
|
||
|
||
// 取消统计和分组订阅，但保留状态订阅以便继续接收状态更新
|
||
final subscriptionsToCancel = _kr_subscriptions.where((sub) {
|
||
final hashStr = sub.hashCode.toString();
|
||
return !hashStr.contains('Status'); // 不取消状态订阅
|
||
}).toList();
|
||
|
||
for (var subscription in subscriptionsToCancel) {
|
||
try {
|
||
await subscription.cancel();
|
||
_kr_subscriptions.remove(subscription);
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('取消订阅时出错: $e');
|
||
}
|
||
}
|
||
|
||
// 不手动设置状态，由 libcore 通过 status stream 自动发送 Stopped 事件
|
||
KRLogUtil.kr_i('✅ SingBox 停止请求已发送', tag: 'SingBox');
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('停止服务时出错: $e');
|
||
KRLogUtil.kr_e('错误堆栈: $stackTrace');
|
||
|
||
// 🔑 即使出错，也要尝试恢复 Windows DNS
|
||
if (Platform.isWindows && _dnsBackedUp) {
|
||
KRLogUtil.kr_w('⚠️ 停止异常，强制执行 DNS 恢复', tag: 'SingBox');
|
||
try {
|
||
await KRWindowsDnsUtil.instance.kr_restoreDnsSettings();
|
||
} catch (dnsError) {
|
||
KRLogUtil.kr_e('❌ 强制 DNS 恢复失败: $dnsError', tag: 'SingBox');
|
||
} finally {
|
||
// 🔧 P0修复2: 异常路径也要重置标志位
|
||
_dnsBackedUp = false;
|
||
KRLogUtil.kr_i('🔄 异常后重置 DNS 备份标志位', tag: 'SingBox');
|
||
}
|
||
}
|
||
|
||
// 不手动设置状态，信任 libcore 的状态管理
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
///
|
||
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');
|
||
|
||
// 🔧 修复：使用 stop + start 而不是 restart
|
||
// 这样可以触发 Windows DNS 恢复和备份逻辑
|
||
try {
|
||
// 1. 先停止（会触发 DNS 恢复）
|
||
await kr_stop();
|
||
|
||
// 2. 等待完全停止
|
||
await Future.delayed(const Duration(milliseconds: 500));
|
||
|
||
// 3. 重新启动（会触发 DNS 备份）
|
||
await kr_start();
|
||
|
||
KRLogUtil.kr_i('✅ SingBox 重启完成', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 重启失败: $e', tag: 'SingBox');
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
//// 设置出站模式
|
||
Future<void> kr_updateConnectionType(KRConnectionType newType) async {
|
||
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;
|
||
}
|
||
|
||
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');
|
||
await kr_restart();
|
||
KRLogUtil.kr_i('✅ VPN重启完成', tag: 'SingBox');
|
||
} else {
|
||
KRLogUtil.kr_i('ℹ️ VPN未启动，配置已更新', tag: 'SingBox');
|
||
}
|
||
} catch (e, stackTrace) {
|
||
KRLogUtil.kr_e('💥 更新连接类型异常: $e', tag: 'SingBox');
|
||
KRLogUtil.kr_e('📚 错误堆栈: $stackTrace', tag: 'SingBox');
|
||
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 {
|
||
KRLogUtil.kr_i('🎯 [v2.1] 开始选择出站节点: $tag', tag: 'SingBox');
|
||
KRLogUtil.kr_i('📊 当前活动组数量: ${kr_activeGroups.length}', tag: 'SingBox');
|
||
|
||
// 如果活动组尚未就绪，等待一段时间；仍为空则仅保存选择，稍后恢复
|
||
if (kr_activeGroups.isEmpty) {
|
||
for (int i = 0; i < 20; i++) {
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
if (kr_activeGroups.isNotEmpty) break;
|
||
}
|
||
if (kr_activeGroups.isEmpty) {
|
||
KRLogUtil.kr_w('⚠️ 活动组为空，跳过即时切换，仅保存选择: $tag', tag: 'SingBox');
|
||
try {
|
||
await KRSecureStorage()
|
||
.kr_saveData(key: _keySelectedNode, value: tag);
|
||
KRLogUtil.kr_i('✅ 节点选择已保存: $tag', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 保存节点选择失败: $e', tag: 'SingBox');
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 🔧 诊断：打印所有活动组的节点，确保目标节点存在
|
||
KRLogUtil.kr_i('🔍 搜索目标节点 "$tag" 在活动组中...', tag: 'SingBox');
|
||
bool foundNode = false;
|
||
for (var group in kr_activeGroups) {
|
||
for (var item in group.items) {
|
||
if (item.tag == tag) {
|
||
foundNode = true;
|
||
KRLogUtil.kr_i('✅ 在组 "${group.tag}" 中找到目标节点: $tag', tag: 'SingBox');
|
||
break;
|
||
}
|
||
}
|
||
if (foundNode) break;
|
||
}
|
||
if (!foundNode) {
|
||
KRLogUtil.kr_w('⚠️ 未能在任何活动组中找到目标节点: $tag', tag: 'SingBox');
|
||
// 打印所有可用的节点
|
||
for (var group in kr_activeGroups) {
|
||
for (var item in group.items) {
|
||
KRLogUtil.kr_d(' 可用节点: ${item.tag}', tag: 'SingBox');
|
||
}
|
||
}
|
||
}
|
||
|
||
// 🔧 关键修复：使用 await 确保保存完成
|
||
try {
|
||
await KRSecureStorage().kr_saveData(key: _keySelectedNode, value: tag);
|
||
KRLogUtil.kr_i('✅ 节点选择已保存: $tag', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 保存节点选择失败: $e', tag: 'SingBox');
|
||
}
|
||
|
||
// 🔧 关键修复：使用 await 确保 command client 初始化完成
|
||
try {
|
||
await _kr_ensureCommandClientInitialized();
|
||
KRLogUtil.kr_i('✅ Command client 已就绪，执行节点切换', tag: 'SingBox');
|
||
|
||
// 🔧 关键修复：使用正确的 group tag
|
||
// libcore 生成的selector组的tag是"proxy"而不是"select"
|
||
final selectorGroupTag =
|
||
kr_activeGroups.any((g) => g.tag == 'select') ? 'select' : 'proxy';
|
||
KRLogUtil.kr_i('⏳ 调用 selectOutbound("$selectorGroupTag", "$tag")...',
|
||
tag: 'SingBox');
|
||
await _kr_selectOutboundWithRetry(selectorGroupTag, tag,
|
||
maxAttempts: 3, initialDelay: 50);
|
||
KRLogUtil.kr_i('✅ 节点切换API调用完成: $tag', tag: 'SingBox');
|
||
|
||
// 🔧 新增：验证节点切换是否生效
|
||
await Future.delayed(const Duration(milliseconds: 300)); // 等待活动组更新
|
||
await _kr_verifyNodeSelection(tag);
|
||
|
||
KRLogUtil.kr_i('✅ 节点切换验证完成: $tag', tag: 'SingBox');
|
||
} catch (e) {
|
||
KRLogUtil.kr_e('❌ 节点选择失败: $e', tag: 'SingBox');
|
||
rethrow; // 抛出异常，让调用者知道失败了
|
||
}
|
||
|
||
// 🔄 如果用户选择了具体节点（不是 auto），启动定期检查和重新选择
|
||
// 这是为了防止 urltest 自动覆盖用户的手动选择
|
||
_nodeSelectionTimer?.cancel();
|
||
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');
|
||
});
|
||
}
|
||
}
|
||
|
||
/// 配合文件地址
|
||
|
||
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");
|
||
|
||
// File tempFile(String fileName) => file("$fileName.tmp");
|
||
|
||
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');
|
||
}
|
||
}
|
||
}
|