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

feat: 提交国家分组功能和debug功能

Browse Source
This commit is contained in:
speakeloudest
2025-11-16 22:50:09 -08:00
parent 76e83e0135
commit 2a1ee3018d
9 changed files with 762 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/app/modules/hi_node_list/controllers/hi_node_list_controller.dart
+53
View File
@@ -12,6 +12,15 @@ class HINodeListController extends GetxController {
/// 首页服务
final KRHomeController homeController = Get.find<KRHomeController>();
/// 调试模式状态
final RxBool isDebugMode = false.obs;
/// 模式按钮点击计数器
int modeButtonClickCount = 0;
/// 最后一次点击时间
DateTime? lastModeButtonClickTime;
/// 获取连接类型字符串
String kr_getConnectionTypeString() {
final connectionType = KRSingBoxImp.instance.kr_connectionType.value;
@@ -41,4 +50,48 @@ class HINodeListController extends GetxController {
}
}
/// 处理模式按钮点击（用于激活调试模式）
void kr_handleModeButtonClick() {
final now = DateTime.now();
// 检查是否在2秒内连续点击
if (lastModeButtonClickTime != null &&
now.difference(lastModeButtonClickTime!).inSeconds > 2) {
// 超过2秒，重置计数器
modeButtonClickCount = 0;
}
modeButtonClickCount++;
lastModeButtonClickTime = now;
KRLogUtil.kr_i('模式按钮点击次数: $modeButtonClickCount', tag: 'HINodeListController');
if (modeButtonClickCount >= 5) {
// 激活调试模式
isDebugMode.value = true;
modeButtonClickCount = 0; // 重置计数器
KRLogUtil.kr_i('🐛 调试模式已激活！', tag: 'HINodeListController');
}
}
/// 获取要显示的节点列表（根据调试模式过滤）
List<dynamic> kr_getFilteredNodeList() {
if (isDebugMode.value) {
// 调试模式：显示所有节点
return kr_subscribeService.allList;
} else {
// 正常模式：只显示 country-auto 节点
return kr_subscribeService.allList.where((node) => node.tag.endsWith('-auto')).toList();
}
}
/// 重置调试模式
void kr_resetDebugMode() {
isDebugMode.value = false;
modeButtonClickCount = 0;
lastModeButtonClickTime = null;
KRLogUtil.kr_i('调试模式已重置', tag: 'HINodeListController');
}
}
lib/app/modules/hi_node_list/views/hi_node_list_view.dart
+93 -80
View File
@@ -231,8 +231,9 @@ class HINodeListView extends GetView<HINodeListController> {
padding: EdgeInsets.symmetric(vertical: 8.w),
// 2. 使用 children 属性，并一次性构建所有列表项
children: [
if (controller.kr_subscribeService.allList.isEmpty)
_buildEmptyListPlaceholder(context, AppTranslations.kr_home.noNodes)
if (controller.kr_getFilteredNodeList().isEmpty)
_buildEmptyListPlaceholder(context,
controller.isDebugMode.value ? '调试模式：无节点数据' : AppTranslations.kr_home.noNodes)
else ...[
InkWell(
// 🔧 修复：改为 async，等待节点切换完成后再关闭列表
@@ -292,13 +293,28 @@ class HINodeListView extends GetView<HINodeListController> {
),
),
// 2. 第二个 Text: "根据网络IP自动匹配最快线路"
Text(
'根据网络IP自动匹配最快线路', // 您指定的文本
style: KrAppTextStyle(
fontSize: 10,
color: Colors.white,
),
),
Obx(() {
// 当选择全局 auto 时，显示当前选中的节点信息
if (controller.homeController.kr_cutTag.value == 'auto') {
final autoNodeInfo = controller.homeController.kr_getGlobalAutoSelectedNode();
if (autoNodeInfo != null) {
return Text(
'当前: ${autoNodeInfo['tag']} (${autoNodeInfo['delay']}ms)',
style: KrAppTextStyle(
fontSize: 10,
color: Colors.white.withOpacity(0.8),
),
);
}
}
return Text(
'根据网络IP自动匹配最快线路', // 默认文本
style: KrAppTextStyle(
fontSize: 10,
color: Colors.white,
),
);
}),
],
),
),
@@ -319,7 +335,7 @@ class HINodeListView extends GetView<HINodeListController> {
),
),
),
...controller.kr_subscribeService.allList.map((item) {
...controller.kr_getFilteredNodeList().map((item) {
return InkWell(
// 🔧 修复：改为 async，等待节点切换完成后再关闭列表
onTap: () async {
@@ -390,78 +406,75 @@ class HINodeListView extends GetView<HINodeListController> {
KRCountryFlag(countryCode: item.country, width: 30.w, height: 20.w, isCircle: false, maintainSize: false),
SizedBox(width: 12.w),
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Row(
children: [
Flexible(
child: Text(
'${controller.homeController.kr_getCountryFullName(item.country)}-${item.tag}',
style: KrAppTextStyle(fontSize: 14, color: Colors.white),
overflow: TextOverflow.ellipsis,
maxLines: 1,
),
),
Obx(() => controller.homeController.kr_cutTag.value == item.tag
? Container(
margin: EdgeInsets.only(left: 4.w),
padding: EdgeInsets.symmetric(horizontal: 4.w, vertical: 1.w),
decoration: BoxDecoration(
color: krModernGreenLight.withOpacity(0.1),
borderRadius: BorderRadius.circular(4.w),
),
child: Text(
AppTranslations.kr_home.selected,
style: KrAppTextStyle(fontSize: 10, color: krModernGreen, fontWeight: FontWeight.w500),
),
)
: const SizedBox.shrink()),
],
child: Obx(() {
final isDebug = controller.isDebugMode.value;
final text = isDebug
? '${controller.homeController.kr_getCountryFullName(item.country)} - ${item.tag}'
: item.country;
return Text(
text,
style: KrAppTextStyle(
fontSize: 16,
fontWeight: FontWeight.w500,
color: Colors.white,
),
SizedBox(height: 2.w),
Obx(() {
// 1. 获取延迟值和测速状态
int displayDelay = item.urlTestDelay.value;
bool isTesting = controller.homeController.kr_isLatency.value;
// 2. 声明文本和颜色变量
String delayText;
Color delayColor;
// 3. 根据状态设置文本和颜色
if (isTesting && displayDelay == 0) {
delayText = '测速中...';
delayColor = Colors.grey; // 测速时使用灰色
} else if (displayDelay == 0) {
delayText = '- ms'; // 未测速或初始状态
delayColor = Colors.grey;
} else if (displayDelay >= 3000) {
delayText = AppTranslations.kr_home.timeout; // "超时"
delayColor = Colors.red; // 超时状态使用红色
} else {
delayText = '${displayDelay}ms';
// 正常延迟，根据快慢设置不同颜色
delayColor = (displayDelay < 500) ? krModernGreen : Colors.orange;
}
// 4. 返回最终的 Text 组件
return Text(
delayText,
style: KrAppTextStyle(
fontSize: 10,
color: delayColor, // 使用动态计算出的颜色
fontWeight: FontWeight.w500,
),
);
}),
Text(
item.city,
style: KrAppTextStyle(fontSize: 12, color: Theme.of(context).textTheme.bodySmall?.color),
),
],
),
);
}),
),
Obx(() {
// 1. 获取延迟值和测速状态
int displayDelay;
bool isTesting = controller.homeController.kr_isLatency.value;
// 极简逻辑：只根据节点类型决定显示方式
print('🔄 _kr_buildNodeListItem节点: item.tag=${item.tag}, country=${item.country}');
// 如果节点本身是auto组节点，显示组内最快节点的速度
if (item.tag.endsWith('-auto')) {
print('🎯 检测到auto组节点，获取最快节点信息');
final autoNodeInfo = controller.homeController.kr_getCountryAutoSelectedNode(item.country);
print('📊 _kr_buildNodeListItem获取auto最快节点: $autoNodeInfo');
displayDelay = autoNodeInfo?['delay'] ?? 0;
print('✅ _kr_buildNodeListItem使用auto最快节点延迟: $displayDelay');
} else {
// 普通节点，直接显示节点自身的速度
displayDelay = item.urlTestDelay.value;
print('🔄 _kr_buildNodeListItem使用普通节点延迟: $displayDelay');
}
// 2. 声明文本和颜色变量
String delayText;
Color delayColor;
// 3. 根据状态设置文本和颜色
if (isTesting && displayDelay == 0) {
delayText = '测速中...';
delayColor = Colors.grey; // 测速时使用灰色
} else if (displayDelay == 0) {
delayText = '- ms'; // 未测速或初始状态
delayColor = Colors.grey;
} else if (displayDelay >= 3000) {
delayText = AppTranslations.kr_home.timeout; // "超时"
delayColor = Colors.red; // 超时状态使用红色
} else {
delayText = '${displayDelay}ms';
// 正常延迟，根据快慢设置不同颜色
delayColor = (displayDelay < 500) ? krModernGreen : Colors.orange;
}
// 4. 返回最终的 Text 组件
return Text(
delayText,
style: KrAppTextStyle(
fontSize: 10,
color: delayColor, // 使用动态计算出的颜色
fontWeight: FontWeight.w500,
),
);
}),
SizedBox(width: 12.w),
Obx(() => controller.homeController.kr_cutTag.value == item.tag
? KrLocalImage(
imageName: 'radio-active-icon',
lib/app/modules/hi_node_list/views/hi_page_node_view.dart
+49 -2
View File
@@ -23,7 +23,49 @@ class HINodePageView extends GetView<HINodeListController> {
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
// 模式切换器
Positioned(
left: 0, // ⭐ 所有内容整体贴到左边
child: Obx(() => controller.isDebugMode.value
? GestureDetector(
onTap: () {
controller.kr_resetDebugMode();
Get.snackbar(
'调试模式',
'已关闭调试模式',
snackPosition: SnackPosition.BOTTOM,
duration: const Duration(seconds: 2),
);
},
child: Container(
padding: EdgeInsets.symmetric(horizontal: 10.w, vertical: 4.w),
decoration: BoxDecoration(
color: Colors.red.withOpacity(0.8),
borderRadius: BorderRadius.circular(12.w),
),
child: Row(
mainAxisSize: MainAxisSize.min,
children: [
Icon(
Icons.bug_report,
size: 12.w,
color: Colors.white,
),
SizedBox(width: 3.w),
Text(
'关闭调试',
style: TextStyle(
fontSize: 10.sp,
color: Colors.white,
fontWeight: FontWeight.w500,
),
),
],
),
),
)
: const SizedBox.shrink()),
),
// 模式切换器
Padding(
padding: EdgeInsets.only(left: 100.w, right: 60.w),
child: Row(
@@ -159,7 +201,12 @@ class HINodePageView extends GetView<HINodeListController> {
}) {
return Expanded(
child: GestureDetector(
onTap: onTap,
onTap: () {
// 处理模式按钮点击（用于调试模式激活）
controller.kr_handleModeButtonClick();
// 执行原有的点击逻辑
onTap();
},
child: AnimatedContainer(
duration: const Duration(milliseconds: 200),
padding: EdgeInsets.symmetric(vertical: 4.w),
lib/app/modules/kr_home/controllers/kr_home_controller.dart
+267 -6
View File
@@ -18,6 +18,7 @@ import '../../../common/app_config.dart';
import '../../../localization/app_translations.dart';
import '../../../localization/kr_language_utils.dart';
import '../../../model/business/kr_group_outbound_list.dart';
import '../../../model/business/kr_outbound_item.dart';
import '../../../services/kr_announcement_service.dart';
import '../../../utils/kr_event_bus.dart';
import '../../../utils/kr_update_util.dart';
@@ -1421,8 +1422,8 @@ class KRHomeController extends GetxController with WidgetsBindingObserver {
/// 获取真实连接的节点信息（auto 模式下获取实际连接的节点）
Map<String, dynamic> kr_getRealConnectedNodeInfo() {
// 如果不是 auto 模式，直接返回当前选中的节点信息
if (kr_cutTag.value != 'auto') {
// 如果不是 auto 模式，也不是 country-auto 模式，直接返回当前选中的节点信息
if (kr_cutTag.value != 'auto' && !kr_cutTag.value.endsWith('-auto')) {
final node = kr_subscribeService.keyList[kr_cutSeletedTag.value];
return {
'nodeName': kr_cutSeletedTag.value,
@@ -1431,11 +1432,13 @@ class KRHomeController extends GetxController with WidgetsBindingObserver {
};
}
// auto 模式下，获取 urltest 组的实际连接节点
// 处理 auto 模式（包括全局 auto 和 country-auto）
print('当前活动组----${KRSingBoxImp.instance.kr_activeGroups.length}');
for (var group in KRSingBoxImp.instance.kr_activeGroups) {
print('当前活动组----$group}');
if (group.type == ProxyType.urltest) {
// 处理全局 auto 模式
if (kr_cutTag.value == 'auto' && group.type == ProxyType.urltest && group.tag == 'auto') {
final selectedNode = group.selected;
final node = kr_subscribeService.keyList[selectedNode];
return {
@@ -1444,12 +1447,39 @@ class KRHomeController extends GetxController with WidgetsBindingObserver {
'country': node?.country ?? '',
};
}
// 处理 country-auto 模式
if (kr_cutTag.value.endsWith('-auto') && group.type == ProxyType.urltest) {
if (group.tag == kr_cutTag.value) {
final selectedNode = group.selected;
final node = kr_subscribeService.keyList[selectedNode];
return {
'nodeName': selectedNode,
'delay': node?.urlTestDelay.value ?? -2,
'country': node?.country ?? '',
};
}
}
}
print('hhhhhh${kr_subscribeService.keyList}', );
// 处理 country-auto 模式的备用方案（当 SingBox 组数据不可用时）
if (kr_cutTag.value.endsWith('-auto')) {
final countryCode = kr_cutTag.value.replaceAll('-auto', '');
KRLogUtil.kr_i('🔄 kr_getRealConnectedNodeInfo 使用备用方案获取 country-auto 信息: $countryCode', tag: 'HomeController');
final autoNodeInfo = kr_getCountryAutoSelectedNode(countryCode);
if (autoNodeInfo != null) {
return {
'nodeName': autoNodeInfo['tag'],
'delay': autoNodeInfo['delay'] ?? -2,
'country': autoNodeInfo['country'] ?? countryCode,
};
}
}
// 如果没有找到 urltest 组，返回默认值
return {
'nodeName': 'auto',
'nodeName': kr_cutTag.value,
'delay': -2,
'country': '',
};
@@ -1470,9 +1500,10 @@ class KRHomeController extends GetxController with WidgetsBindingObserver {
/// 获取真实连接的节点国家
String kr_getRealConnectedNodeCountry() {
final info = kr_getRealConnectedNodeInfo();
final delay = kr_currentNodeLatency.value;
final delay = info['delay'] as int; // 使用真实连接的节点延迟，而不是 kr_currentNodeLatency.value
final country1 = kr_getCurrentNodeCountry();
print('country----$country1');
print('kr_getRealConnectedNodeCountry - delay from info: $delay, country from info: ${info['country']}');
final country = kr_getCountryFullName(info['country']);
if (delay == -2) {
return '--';
@@ -2181,6 +2212,225 @@ class KRHomeController extends GetxController with WidgetsBindingObserver {
});
}
/// 获取国家-auto组的当前选中子节点信息
Map<String, dynamic>? kr_getCountryAutoSelectedNode(String countryCode) {
try {
final activeGroups = KRSingBoxImp.instance.kr_activeGroups;
final allGroups = KRSingBoxImp.instance.kr_allGroups;
final autoGroupTag = '${countryCode}-auto';
KRLogUtil.kr_i('🔍 开始获取国家-auto选中节点: countryCode=$countryCode, autoGroupTag=$autoGroupTag', tag: 'HomeController');
KRLogUtil.kr_i('📊 活跃组数量: ${activeGroups.length}, 所有组数量: ${allGroups.length}', tag: 'HomeController');
// 优先检查活跃组
if (activeGroups.isNotEmpty) {
KRLogUtil.kr_i('✅ 活跃组不为空，优先检查活跃组', tag: 'HomeController');
for (var group in activeGroups) {
KRLogUtil.kr_i('🔄 检查活跃组: tag=${group.tag}, type=${group.type}, selected=${group.selected}', tag: 'HomeController');
if (group.tag == autoGroupTag && group.type == ProxyType.urltest) {
KRLogUtil.kr_i('✅ 在活跃组中找到匹配的urltest组: $autoGroupTag', tag: 'HomeController');
return _kr_extractSelectedNodeInfo(group, countryCode);
}
}
}
// 如果活跃组中没有，检查所有组
if (allGroups.isNotEmpty) {
KRLogUtil.kr_i('🔍 活跃组中未找到，检查所有组', tag: 'HomeController');
for (var group in allGroups) {
KRLogUtil.kr_i('🔄 检查所有组: tag=${group.tag}, type=${group.type}, selected=${group.selected}', tag: 'HomeController');
if (group.tag == autoGroupTag && group.type == ProxyType.urltest) {
KRLogUtil.kr_i('✅ 在所有组中找到匹配的urltest组: $autoGroupTag', tag: 'HomeController');
return _kr_extractSelectedNodeInfo(group, countryCode);
}
}
}
// 如果组数据都为空，使用备用方案：从订阅服务中找该国家最快的节点
KRLogUtil.kr_i('🔄 组数据为空，使用备用方案从订阅服务获取最快节点', tag: 'HomeController');
return _kr_getFastestNodeFromSubscribeService(countryCode);
} catch (e) {
KRLogUtil.kr_e('💥 获取国家-auto选中节点异常: $e', tag: 'HomeController');
}
return null;
}
/// 从订阅服务获取该国家最快节点的备用方案
Map<String, dynamic>? _kr_getFastestNodeFromSubscribeService(String countryCode) {
try {
KRLogUtil.kr_i('🔄 使用订阅服务查找国家最快节点: $countryCode', tag: 'HomeController');
// 从订阅服务中获取该国家的所有节点
final allNodes = kr_subscribeService.allList.where((node) =>
node.country == countryCode && !node.tag.endsWith('-auto')
).toList();
KRLogUtil.kr_i('📊 找到 ${allNodes.length} 个该国家的普通节点', tag: 'HomeController');
if (allNodes.isEmpty) {
KRLogUtil.kr_w('⚠️ 未找到该国家的任何普通节点: $countryCode', tag: 'HomeController');
return null;
}
// 找出延迟最小的节点（排除0和超时）
KROutboundItem? fastestNode;
int fastestDelay = 999999;
for (var node in allNodes) {
final delay = node.urlTestDelay.value;
if (delay > 0 && delay < 3000 && delay < fastestDelay) {
fastestDelay = delay;
fastestNode = node;
}
}
if (fastestNode != null) {
KRLogUtil.kr_i('✅ 找到最快节点: ${fastestNode.tag}, 延迟: ${fastestDelay}ms', tag: 'HomeController');
return {
'tag': fastestNode.tag,
'delay': fastestDelay,
'country': countryCode,
};
} else {
KRLogUtil.kr_w('⚠️ 该国家的节点都没有有效延迟数据', tag: 'HomeController');
return null;
}
} catch (e) {
KRLogUtil.kr_e('💥 获取订阅服务最快节点异常: $e', tag: 'HomeController');
return null;
}
}
/// 提取选中节点信息的辅助方法
Map<String, dynamic>? _kr_extractSelectedNodeInfo(dynamic group, String countryCode) {
try {
// 获取当前选中的节点
final selectedNode = group.selected;
KRLogUtil.kr_i('🎯 当前选中节点: $selectedNode', tag: 'HomeController');
KRLogUtil.kr_i('📋 组内项目数量: ${group.items.length}', tag: 'HomeController');
if (selectedNode != null && selectedNode.isNotEmpty) {
KRLogUtil.kr_i('✅ 选中节点有效，开始查找节点详情', tag: 'HomeController');
// 打印所有节点信息用于调试
for (var item in group.items) {
KRLogUtil.kr_i('📄 组内节点: tag=${item.tag}, delay=${item.urlTestDelay}', tag: 'HomeController');
}
// 在组内查找选中的节点
try {
final selectedItem = group.items.firstWhere(
(item) => item.tag == selectedNode,
);
KRLogUtil.kr_i('🎉 成功找到选中节点: tag=${selectedItem.tag}, delay=${selectedItem.urlTestDelay}', tag: 'HomeController');
return {
'tag': selectedNode,
'delay': selectedItem.urlTestDelay,
'country': countryCode,
};
} catch (e) {
KRLogUtil.kr_e('❌ 在组内未找到选中节点: $selectedNode', tag: 'HomeController');
return null;
}
} else {
KRLogUtil.kr_w('⚠️ 选中节点为空或无效', tag: 'HomeController');
return null;
}
} catch (e) {
KRLogUtil.kr_e('💥 提取选中节点信息异常: $e', tag: 'HomeController');
return null;
}
}
/// 获取全局 auto 组的当前选中子节点信息
Map<String, dynamic>? kr_getGlobalAutoSelectedNode() {
try {
final activeGroups = KRSingBoxImp.instance.kr_activeGroups;
KRLogUtil.kr_i('🌍 开始获取全局auto选中节点信息', tag: 'HomeController');
KRLogUtil.kr_i('📊 活跃组数量: ${activeGroups.length}', tag: 'HomeController');
for (var group in activeGroups) {
KRLogUtil.kr_i('🔄 检查全局组: tag=${group.tag}, type=${group.type}, selected=${group.selected}', tag: 'HomeController');
KRLogUtil.kr_i('📋 全局组内项目数量: ${group.items.length}', tag: 'HomeController');
if (group.tag == 'auto' && group.type == ProxyType.urltest) {
KRLogUtil.kr_i('✅ 找到全局auto urltest组', tag: 'HomeController');
// 获取当前选中的节点
final selectedNode = group.selected;
KRLogUtil.kr_i('🎯 全局auto当前选中节点: $selectedNode', tag: 'HomeController');
if (selectedNode != null && selectedNode.isNotEmpty) {
KRLogUtil.kr_i('✅ 全局auto选中节点有效，开始查找详情', tag: 'HomeController');
// 打印所有节点信息用于调试
for (var item in group.items) {
KRLogUtil.kr_i('📄 全局auto组内节点: tag=${item.tag}, delay=${item.urlTestDelay}', tag: 'HomeController');
}
// 在组内查找选中的节点
try {
final selectedItem = group.items.firstWhere(
(item) => item.tag == selectedNode,
);
KRLogUtil.kr_i('🎉 成功找到全局auto选中节点: tag=${selectedItem.tag}, delay=${selectedItem.urlTestDelay}', tag: 'HomeController');
return {
'tag': selectedNode,
'delay': selectedItem.urlTestDelay,
'country': '',
};
} catch (e) {
KRLogUtil.kr_e('❌ 在全局auto组内未找到选中节点: $selectedNode', tag: 'HomeController');
return null;
}
} else {
KRLogUtil.kr_w('⚠️ 全局auto选中节点为空或无效', tag: 'HomeController');
}
}
}
KRLogUtil.kr_w('❌ 未找到全局auto组', tag: 'HomeController');
} catch (e) {
KRLogUtil.kr_e('💥 获取全局auto选中节点异常: $e', tag: 'HomeController');
}
return null;
}
/// 获取指定国家的所有真实节点延迟列表
List<Map<String, dynamic>> kr_getCountryRealNodeDelays(String countryCode) {
final delays = <Map<String, dynamic>>[];
try {
// 从订阅服务中获取该国家的节点列表
final countryNodes = kr_subscribeService.keyList.values
.where((item) => item.country == countryCode && !item.tag.endsWith('-auto'))
.toList();
for (final node in countryNodes) {
delays.add({
'tag': node.tag,
'delay': node.urlTestDelay.value,
'city': node.city,
});
}
// 按延迟排序
delays.sort((a, b) => a['delay'].compareTo(b['delay']));
} catch (e) {
KRLogUtil.kr_e('获取国家真实节点延迟列表失败: $e', tag: 'HomeController');
}
return delays;
}
/// 尝试从活动组更新延迟值
bool _kr_tryUpdateDelayFromActiveGroups() {
try {
@@ -2206,6 +2456,17 @@ class KRHomeController extends GetxController with WidgetsBindingObserver {
}
}
}
// 如果是国家-auto模式，从对应的国家urltest组获取延迟
else if (kr_cutTag.value.endsWith('-auto')) {
final countryCode = kr_cutTag.value.replaceAll('-auto', '');
for (var item in group.items) {
if (item.tag == kr_cutTag.value && item.urlTestDelay != 0) {
kr_currentNodeLatency.value = item.urlTestDelay;
KRLogUtil.kr_i('✅ ${countryCode}-auto模式延迟值: ${item.urlTestDelay}ms', tag: 'HomeController');
return true;
}
}
}
// 手动选择模式
else {
for (var item in group.items) {