HI-VPN/hi-client
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. ✅ /lib/app/common/app_config.dart

Browse Source 
- P0: 限制递归重试次数（最多5次）
    - P1: 减少超时时间（3s→2s, 6s→4s）
    - P1: 移除重复域名配置
  2. ✅ /lib/app/services/kr_site_config_service.dart
    - P1: 减少网络超时（10s→5s）
  3. ✅ /lib/app/modules/kr_splash/controllers/kr_splash_controller.dart
    - P0: 总体超时保护（30秒）
    - P2: 非阻塞初始化
    - P2: 后台任务超时保护（网站配置10s, 设备登录8s）
    - P2: 完善错误处理（区分超时/网络/HTTP错误）
    - P3: 跳过初始化功能
  4. ✅ /lib/app/modules/kr_splash/views/kr_splash_view.dart
    - P3: 添加"跳过"按钮

(cherry picked from commit 0a9fe429919fe9ae85b7769df123b72d7e33c6b1)
This commit is contained in:
Rust
2025-10-31 01:50:25 -07:00
committed by speakeloudest
parent c5715f77e2
commit 442ea458b7
4 changed files with 282 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/app/common/app_config.dart
+26 -2
View File
@@ -53,8 +53,9 @@ class KRDomain {
static Timer? _retryTimer;
static const int kr_retryInterval = 2; // 基础重试间隔（秒）
static const int kr_maxRetryCount = 2; // 最大重试次数
static const int kr_domainTimeout = 3; // 域名检测超时时间（秒）
static const int kr_totalTimeout = 6; // 总体超时时间（秒）
// 🔧 P1修复：减少域名检测超时时间
static const int kr_domainTimeout = 2; // 域名检测超时时间（秒）3→2
static const int kr_totalTimeout = 4; // 总体超时时间（秒）6→4
static Set<String> _triedDomains = {}; // 已尝试过的域名集合
static Map<String, int> _domainResponseTimes = {}; // 域名响应时间记录
static Map<String, DateTime> _domainLastCheck = {}; // 域名最后检测时间
@@ -1057,6 +1058,7 @@ class AppConfig {
/// 请求域名地址
/// 基础url
///
// static String baseUrl = "http://103.112.98.72:8088";
/// 请求域名地址
@@ -1146,9 +1148,23 @@ class AppConfig {
Future<void> _startAutoRetry(Future<void> Function()? onSuccess) async {
_retryTimer?.cancel();
int currentRetryCount = 0;
// 🔧 P0修复：添加总体尝试次数限制，防止无限递归
int totalAttempts = 0;
const int maxTotalAttempts = 5; // 最多5次尝试（包括域名切换后的重试）
Future<void> executeConfigRequest() async {
try {
// 🔧 P0修复：检查总体尝试次数
totalAttempts++;
if (totalAttempts > maxTotalAttempts) {
KRLogUtil.kr_e('❌ 超过最大总尝试次数($maxTotalAttempts)，停止重试', tag: 'AppConfig');
// 使用默认配置继续启动
if (onSuccess != null) {
await onSuccess();
}
return;
}
// 检查是否超过最大重试次数
if (currentRetryCount >= kr_maxRetryCount) {
KRLogUtil.kr_w('达到最大重试次数，尝试使用备用域名', tag: 'AppConfig');
@@ -1158,8 +1174,16 @@ class AppConfig {
KRDomain.kr_currentDomain = newDomain;
await KRDomain.kr_saveCurrentDomain();
KRLogUtil.kr_i('✅ 最终切换到备用域名: $newDomain', tag: 'AppConfig');
// 重置当前重试计数，但保留总尝试次数
currentRetryCount = 0;
// 继续重试配置请求
await executeConfigRequest();
} else {
KRLogUtil.kr_e('❌ 备用域名切换失败，使用默认配置继续', tag: 'AppConfig');
// 使用默认配置继续启动
if (onSuccess != null) {
await onSuccess();
}
}
return;
}
lib/app/modules/kr_splash/controllers/kr_splash_controller.dart
+201 -85
View File
@@ -1,8 +1,10 @@
import 'package:get/get.dart';
import 'dart:convert';
import 'dart:io' show Platform;
import 'dart:io' show Platform, SocketException;
import 'dart:math';
import 'dart:async';
import 'package:dio/dio.dart';
import 'package:kaer_with_panels/app/utils/kr_network_check.dart';
import 'package:kaer_with_panels/app/utils/kr_log_util.dart';
import 'package:kaer_with_panels/app/routes/app_pages.dart';
@@ -66,11 +68,14 @@ class KRSplashController extends GetxController {
KRLogUtil.kr_i('[SPLASH_TIMING] 🎬 启动页控制器 onInit', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] ═══════════════════════════════════════', tag: 'SplashController');
// 异步初始化网站配置
_kr_initSiteConfig().then((_) {
print('🔧 网站配置完成，开始调用 _kr_initialize...');
// 🔧 P2优化：网站配置和设备登录在后台执行，不阻塞主流程
print('🌐 启动后台任务：网站配置加载...');
KRLogUtil.kr_i('🌐 后台任务：网站配置和设备登录', tag: 'SplashController');
_kr_initSiteConfig(); // 不等待完成，在后台执行
// 立即开始主初始化流程
print('🔧 立即开始主初始化流程...');
_kr_initialize();
});
}
// 记录步骤耗时的辅助方法
@@ -87,7 +92,7 @@ class KRSplashController extends GetxController {
_stepStartTime = now; // 更新步骤开始时间
}
/// 初始化网站配置（异步执行）
/// 初始化网站配置（后台执行，不阻塞主流程）
Future<void> _kr_initSiteConfig() async {
print('[SPLASH_TIMING] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
print('[SPLASH_TIMING] 🌐 开始初始化网站配置...');
@@ -98,6 +103,27 @@ class KRSplashController extends GetxController {
KRLogUtil.kr_i('[SPLASH_TIMING] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
try {
// 🔧 P2优化：为后台任务添加10秒超时保护
await Future.any([
_executeSiteConfigInit(),
Future.delayed(const Duration(seconds: 10), () {
throw TimeoutException('网站配置加载超时（10秒）');
}),
]);
} on TimeoutException catch (e) {
print('⏱️ 网站配置加载超时，应用将使用默认配置: $e');
KRLogUtil.kr_w('⏱️ 网站配置加载超时: $e', tag: 'SplashController');
} catch (e) {
print('❌ 网站配置初始化异常: $e');
KRLogUtil.kr_e('❌ 网站配置初始化异常: $e', tag: 'SplashController');
}
print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
}
/// 执行网站配置初始化
Future<void> _executeSiteConfigInit() async {
print('📞 准备调用 KRSiteConfigService().initialize()...');
final success = await KRSiteConfigService().initialize();
final crispId = await KRSiteConfigService().getCrispId();
@@ -110,108 +136,201 @@ class KRSplashController extends GetxController {
print('AppConfig website_id 已更新为: ${config.kr_website_id}');
print('[SPLASH_TIMING] ✅ 网站配置初始化成功');
KRLogUtil.kr_i('[SPLASH_TIMING] ✅ 网站配置初始化成功', tag: 'SplashController');
await _kr_checkAndPerformDeviceLogin();
} else {
print('⚠️ 网站配置初始化失败，将使用默认配置');
KRLogUtil.kr_w('⚠️ 网站配置初始化失败，将使用默认配置', tag: 'SplashController');
}
} catch (e) {
print('❌ 网站配置初始化异常: $e');
KRLogUtil.kr_e('❌ 网站配置初始化异常: $e', tag: 'SplashController');
}
/// 检查并执行设备登录（后台执行，有超时保护）
Future<void> _kr_checkAndPerformDeviceLogin() async {
try {
print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
print('🔍 检查是否支持设备登录...');
print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
final siteConfigService = KRSiteConfigService();
// 检查是否启用设备登录
final isDeviceLoginEnabled = siteConfigService.isDeviceLoginEnabled();
print('📱 设备登录状态: ${isDeviceLoginEnabled ? "已启用" : "未启用"}');
KRLogUtil.kr_i('📱 设备登录状态: $isDeviceLoginEnabled', tag: 'SplashController');
if (!isDeviceLoginEnabled) {
print('⚠️ 设备登录未启用，跳过自动登录');
KRLogUtil.kr_w('⚠️ 设备登录未启用', tag: 'SplashController');
return;
}
print('✅ 设备登录已启用，开始初始化设备信息...');
// 🔧 P2优化：为设备登录添加8秒超时保护
await Future.any([
_executeDeviceLogin(),
Future.delayed(const Duration(seconds: 8), () {
throw TimeoutException('设备登录超时（8秒）');
}),
]);
print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
} on TimeoutException catch (e) {
print('⏱️ 设备登录超时，应用将继续启动: $e');
KRLogUtil.kr_w('⏱️ 设备登录超时: $e', tag: 'SplashController');
} catch (e, stackTrace) {
print('❌ 设备登录检查异常: $e');
print('📚 堆栈跟踪: $stackTrace');
KRLogUtil.kr_e('❌ 设备登录检查异常: $e', tag: 'SplashController');
}
}
/// 执行设备登录
Future<void> _executeDeviceLogin() async {
// 初始化设备信息服务
await KRDeviceInfoService().initialize();
print('🔐 开始执行设备登录...');
KRLogUtil.kr_i('🔐 开始执行设备登录', tag: 'SplashController');
// 执行设备登录
final authApi = KRAuthApi();
final result = await authApi.kr_deviceLogin();
result.fold(
(error) {
print('❌ 设备登录失败: ${error.msg}');
KRLogUtil.kr_e('❌ 设备登录失败: ${error.msg}', tag: 'SplashController');
},
(token) async {
print('✅ 设备登录成功！');
print('🎫 Token: ${token.substring(0, min(20, token.length))}...');
KRLogUtil.kr_i('✅ 设备登录成功', tag: 'SplashController');
// 使用 saveUserInfo 保存完整的用户信息
// 设备登录使用特殊的账号标识，登录类型设为邮箱（后续可以绑定真实账号）
final deviceId = KRDeviceInfoService().deviceId ?? 'unknown';
await KRAppRunData.getInstance().kr_saveUserInfo(
token,
'device_$deviceId', // 使用设备ID作为临时账号
KRLoginType.kr_email, // 默认登录类型
null, // 设备登录无需区号
);
print('💾 用户信息已保存（包括Token）');
print('✅ 已标记为登录状态');
KRLogUtil.kr_i('✅ 设备登录流程完成', tag: 'SplashController');
},
);
}
Future<void> _kr_initialize() async {
try {
_logStepTiming('开始主要初始化流程');
KRLogUtil.kr_i('[SPLASH_TIMING] 🔧 开始执行 _kr_initialize', tag: 'SplashController');
KRLogUtil.kr_i('🔧 开始执行 _kr_initialize', tag: 'SplashController');
// 🔧 P0修复：添加总体超时保护（30秒）
await Future.any([
_executeInitialization(),
Future.delayed(const Duration(seconds: 30), () {
throw TimeoutException('初始化超时：30秒内未完成');
}),
]);
} on TimeoutException catch (e) {
// 🔧 P2优化：超时错误提供更友好的提示
KRLogUtil.kr_e('⏱️ 初始化超时: $e', tag: 'SplashController');
print('⏱️ 初始化超时，直接跳转到主页');
// 超时后直接跳转到主页，让用户可以手动重试
Get.offAllNamed(Routes.KR_MAIN);
} on SocketException catch (e) {
// 🔧 P2优化：网络连接错误
KRLogUtil.kr_e('❌ 网络连接错误: $e', tag: 'SplashController');
_handleError('网络连接失败', '请检查您的网络连接是否正常，然后重试。');
} on DioException catch (e) {
// 🔧 P2优化：HTTP请求错误
KRLogUtil.kr_e('❌ HTTP请求错误: ${e.type} - ${e.message}', tag: 'SplashController');
final errorMsg = _getDioErrorMessage(e);
_handleError('服务请求失败', errorMsg);
} catch (e) {
// 🔧 P2优化：其他未知错误
KRLogUtil.kr_e('❌ 未知初始化异常: $e', tag: 'SplashController');
_handleError('初始化失败', '应用启动时发生错误，请尝试重启应用或清除缓存。');
}
}
/// 处理错误并显示
void _handleError(String title, String message) {
kr_hasError.value = true;
kr_errorMessage.value = '$title\n\n$message';
}
/// 获取Dio错误的友好提示
String _getDioErrorMessage(DioException e) {
switch (e.type) {
case DioExceptionType.connectionTimeout:
case DioExceptionType.sendTimeout:
case DioExceptionType.receiveTimeout:
return '请求超时，请检查网络连接后重试。';
case DioExceptionType.badResponse:
final statusCode = e.response?.statusCode;
if (statusCode == 404) {
return '服务地址未找到（404），请联系管理员。';
} else if (statusCode == 500) {
return '服务器内部错误（500），请稍后重试。';
} else if (statusCode == 401 || statusCode == 403) {
return '访问被拒绝（$statusCode），请检查配置。';
}
return '服务器返回错误（$statusCode），请稍后重试。';
case DioExceptionType.cancel:
return '请求已取消';
case DioExceptionType.connectionError:
return '无法连接到服务器，请检查网络设置。';
default:
return '网络请求失败，请检查网络后重试。';
}
}
// 🔧 P0修复：将原来的初始化逻辑提取到单独方法
Future<void> _executeInitialization() async {
// 只在手机端检查网络权限
if (Platform.isIOS || Platform.isAndroid) {
_logStepTiming('开始网络权限检查');
KRLogUtil.kr_i('[SPLASH_TIMING] 📱 移动平台，检查网络权限...', tag: 'SplashController');
KRLogUtil.kr_i('📱 移动平台，检查网络权限...', tag: 'SplashController');
final bool hasNetworkPermission = await KRNetworkCheck.kr_initialize(
Get.context!,
onPermissionGranted: () async {
_logStepTiming('网络权限检查完成');
await _kr_continueInitialization();
},
);
if (!hasNetworkPermission) {
// 计算网络权限失败时的总耗时
final endTime = DateTime.now();
final totalDuration = endTime.difference(_startTime);
final totalMs = totalDuration.inMilliseconds;
print('❌ 网络权限失败时间: ${endTime.toIso8601String()}');
print('🕐 网络权限失败总耗时: ${totalMs}ms (${totalDuration.inSeconds}.${(totalMs % 1000).toString().padLeft(3, '0')}s)');
kr_hasError.value = true;
kr_errorMessage.value = AppTranslations.kr_splash.kr_networkPermissionFailed;
KRLogUtil.kr_e('❌ 网络权限检查失败', tag: 'SplashController');
KRLogUtil.kr_e('⏰ 网络权限失败总耗时: ${totalMs}ms', tag: 'SplashController');
return;
}
} else {
// 非手机端直接继续初始化
_logStepTiming('桌面平台跳过权限检查');
KRLogUtil.kr_i('[SPLASH_TIMING] 💻 桌面平台，直接执行初始化', tag: 'SplashController');
KRLogUtil.kr_i('💻 桌面平台，直接执行初始化', tag: 'SplashController');
await _kr_continueInitialization();
}
} catch (e) {
// 计算初始化异常时的总耗时
final endTime = DateTime.now();
final totalDuration = endTime.difference(_startTime);
final totalMs = totalDuration.inMilliseconds;
print('❌ 初始化异常时间: ${endTime.toIso8601String()}');
print('🕐 初始化异常总耗时: ${totalMs}ms (${totalDuration.inSeconds}.${(totalMs % 1000).toString().padLeft(3, '0')}s)');
KRLogUtil.kr_e('❌ _kr_initialize 异常: $e', tag: 'SplashController');
KRLogUtil.kr_e('⏰ 初始化异常总耗时: ${totalMs}ms', tag: 'SplashController');
kr_hasError.value = true;
kr_errorMessage.value = '${AppTranslations.kr_splash.kr_initializationFailed}$e';
}
}
Future<void> _kr_continueInitialization() async {
try {
_logStepTiming('开始继续初始化流程');
KRLogUtil.kr_i('[SPLASH_TIMING] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] 🚀 启动页主流程开始...', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
KRLogUtil.kr_i('🚀 启动页主流程开始...', tag: 'SplashController');
KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
// 只在手机端检查网络连接
if (Platform.isIOS || Platform.isAndroid) {
_logStepTiming('开始网络连接检查');
KRLogUtil.kr_i('[SPLASH_TIMING] 📱 检查网络连接...', tag: 'SplashController');
KRLogUtil.kr_i('📱 检查网络连接...', tag: 'SplashController');
final bool isConnected = await KRNetworkCheck.kr_checkNetworkConnection();
if (!isConnected) {
// 计算网络连接失败时的总耗时
final endTime = DateTime.now();
final totalDuration = endTime.difference(_startTime);
final totalMs = totalDuration.inMilliseconds;
print('❌ 网络连接失败时间: ${endTime.toIso8601String()}');
print('🕐 网络连接失败总耗时: ${totalMs}ms (${totalDuration.inSeconds}.${(totalMs % 1000).toString().padLeft(3, '0')}s)');
kr_hasError.value = true;
kr_errorMessage.value = AppTranslations.kr_splash.kr_networkConnectionFailed;
KRLogUtil.kr_e('❌ 网络连接失败', tag: 'SplashController');
KRLogUtil.kr_e('⏰ 网络连接失败总耗时: ${totalMs}ms', tag: 'SplashController');
return;
}
_logStepTiming('网络连接检查完成');
KRLogUtil.kr_i('[SPLASH_TIMING] ✅ 网络连接正常', tag: 'SplashController');
KRLogUtil.kr_i('✅ 网络连接正常', tag: 'SplashController');
} else {
_logStepTiming('桌面平台跳过网络检查');
KRLogUtil.kr_i('[SPLASH_TIMING] 💻 桌面平台，跳过网络连接检查', tag: 'SplashController');
KRLogUtil.kr_i('💻 桌面平台，跳过网络连接检查', tag: 'SplashController');
}
// 网络检查完成后执行设备登录（始终支持）
@@ -234,25 +353,17 @@ class KRSplashController extends GetxController {
_logStepTiming('设备登录检查完成');
// 初始化配置
KRLogUtil.kr_i('⚙️ 开始初始化应用配置...', tag: 'SplashController');
await AppConfig().initConfig(
onSuccess: () async {
// 配置初始化成功,没有配置
KRLogUtil.kr_i('[SPLASH_TIMING] ⚙️ 初始化应用配置...', tag: 'SplashController');
// 配置初始化成功，继续后续步骤
KRLogUtil.kr_i('✅ 应用配置初始化成功，继续后续步骤', tag: 'SplashController');
await _kr_continueAfterConfig();
},
);
} catch (e) {
// 计算配置初始化异常时的总耗时
final endTime = DateTime.now();
final totalDuration = endTime.difference(_startTime);
final totalMs = totalDuration.inMilliseconds;
print('❌ 配置初始化异常时间: ${endTime.toIso8601String()}');
print('🕐 配置初始化异常总耗时: ${totalMs}ms (${totalDuration.inSeconds}.${(totalMs % 1000).toString().padLeft(3, '0')}s)');
// 配置初始化失败，显示错误信息
KRLogUtil.kr_e('❌ 启动页初始化异常: $e', tag: 'SplashController');
KRLogUtil.kr_e('⏰ 配置初始化异常总耗时: ${totalMs}ms', tag: 'SplashController');
kr_hasError.value = true;
kr_errorMessage.value = '${AppTranslations.kr_splash.kr_initializationFailed}$e';
}
@@ -285,20 +396,11 @@ class KRSplashController extends GetxController {
}
print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
// 计算总耗时
final endTime = DateTime.now();
final totalDuration = endTime.difference(_startTime);
final totalMs = totalDuration.inMilliseconds;
print('[SPLASH_TIMING] ⏰ 启动结束时间: ${endTime.toIso8601String()}');
print('[SPLASH_TIMING] 🕐 启动总耗时: ${totalMs}ms (${totalDuration.inSeconds}.${(totalMs % 1000).toString().padLeft(3, '0')}s)');
KRLogUtil.kr_i('[SPLASH_TIMING] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] 🎯 准备进入主页', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] 📊 最终登录状态: $loginStatus', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] 🎫 Token存在: $hasToken', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] ⏰ 启动总耗时: ${totalMs}ms', tag: 'SplashController');
KRLogUtil.kr_i('[SPLASH_TIMING] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
KRLogUtil.kr_i('🎯 准备进入主页', tag: 'SplashController');
KRLogUtil.kr_i('📊 最终登录状态: $loginStatus', tag: 'SplashController');
KRLogUtil.kr_i('🎫 Token存在: $hasToken', tag: 'SplashController');
KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
// 直接导航到主页（无论是否登录，主页会根据登录状态显示不同内容）
_logStepTiming('开始页面导航');
@@ -377,6 +479,20 @@ class KRSplashController extends GetxController {
_kr_initialize();
}
// 🔧 P3优化：跳过初始化，直接进入主页
void kr_skipInitialization() {
KRLogUtil.kr_i('⏭️ 用户选择跳过初始化', tag: 'SplashController');
print('⏭️ 用户跳过初始化，直接进入主页');
// 重置状态
kr_hasError.value = false;
kr_errorMessage.value = '';
kr_isLoading.value = false;
// 直接跳转到主页
Get.offAllNamed(Routes.KR_MAIN);
}
@override
void onReady() {
super.onReady();
lib/app/modules/kr_splash/views/kr_splash_view.dart
+19
View File
@@ -89,6 +89,25 @@ class KRSplashView extends GetView<KRSplashController> {
color: Theme.of(context).primaryColor,
),
),
SizedBox(height: 16.h),
// 🔧 P3优化：添加跳过按钮
TextButton(
onPressed: controller.kr_skipInitialization,
style: TextButton.styleFrom(
foregroundColor: Colors.grey,
padding: EdgeInsets.symmetric(
horizontal: 24.w,
vertical: 8.h,
),
),
child: Text(
'跳过',
style: KrAppTextStyle(
fontSize: 14,
color: Colors.grey,
),
),
),
],
);
}
lib/app/services/kr_site_config_service.dart
+4 -4
View File
@@ -12,10 +12,10 @@ class KRSiteConfigService extends ChangeNotifier {
static final KRSiteConfigService _instance = KRSiteConfigService._internal();
factory KRSiteConfigService() => _instance;
KRSiteConfigService._internal() {
// 配置 Dio 默认超时设置
_dio.options.connectTimeout = const Duration(seconds: 10);
_dio.options.sendTimeout = const Duration(seconds: 10);
_dio.options.receiveTimeout = const Duration(seconds: 10);
// 🔧 P1修复：减少超时时间 10秒 → 5秒
_dio.options.connectTimeout = const Duration(seconds: 5);
_dio.options.sendTimeout = const Duration(seconds: 5);
_dio.options.receiveTimeout = const Duration(seconds: 5);
// 🔧 配置HttpClientAdapter使用sing-box的mixed代理
_dio.httpClientAdapter = IOHttpClientAdapter(