Initial commit: 91dj android client dev_1.0.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
谢宇宁
2026-10-08 11:37:25 +07:00
co-authored by Claude Opus 5.5
commit 97dd6a739a
1262 changed files with 119813 additions and 0 deletions
@@ -0,0 +1,204 @@
import 'dart:async';
import 'dart:convert';
import 'package:analytics_sdk/config/sdk_config.dart';
import 'package:analytics_sdk/utils/logger.dart';
import 'package:analytics_sdk/utils/platform_storage.dart';
import 'package:http/http.dart' as http;
/// 域名管理器:对业务方传入的域名列表进行并发测速,选择最快的上报域名
class DomainManager {
static final DomainManager instance = DomainManager._internal();
factory DomainManager() => instance;
DomainManager._internal();
List<String> _reportDomains = [];
String? _fastestDomain;
/// 每次 initWithDomains / reset 时递增,用于丢弃过期测速结果
int _generation = 0;
http.Client? _httpClient;
http.Client get _client => _httpClient ??= http.Client();
/// 域名更新回调,当最快域名选出后调用
Function(String? fastestDomain)? onFastestDomainChanged;
/// 获取最快的上报域名
String? get fastestDomain => _fastestDomain;
/// 获取所有上报域名
List<String> get reportDomains => List.unmodifiable(_reportDomains);
/// 传入已解密的域名列表,执行并发测速并选出最快域名
///
/// [domains] 每项为带协议的完整域名,如 "https://api.example.com"
///
/// 注意:此方法设计为 fire-and-forget,调用方无需 await,
/// 测速完成后通过 [onFastestDomainChanged] 回调通知结果。
Future<String?> initWithDomains(List<String> domains) async {
// 记录本次调用的代次,测速完成后用于判断结果是否已过期
final gen = ++_generation;
try {
if (domains.isEmpty) {
Logger.domainManager('域名列表为空,跳过测速', level: LogLevel.warn);
return null;
}
_reportDomains = domains;
Logger.domainManager('开始域名测速,共 ${domains.length} 个: $domains');
String? fastest;
if (domains.length == 1) {
fastest = domains.first;
Logger.domainManager('只有一个域名,跳过测速: $fastest');
} else {
fastest = await _speedTestAndSelect(domains);
Logger.domainManager('测速完成,最快域名: $fastest');
}
// 若 reset() 或新一轮 initWithDomains 已被调用,丢弃本次过期结果
if (gen != _generation) {
Logger.domainManager('测速结果已过期(generation 不匹配),忽略本次结果');
return null;
}
_fastestDomain = fastest;
// 测速完成后持久化域名列表(供下次 init 时解密失败时作为降级)
_saveDomainCache();
if (onFastestDomainChanged != null && _fastestDomain != null) {
try {
onFastestDomainChanged!(_fastestDomain);
} catch (e) {
Logger.domainManager('域名更新回调异常: $e');
}
}
return _fastestDomain;
} catch (e) {
Logger.domainManager('域名测速失败: $e', level: LogLevel.warn);
return null;
}
}
/// 重置域名管理器状态,供 re-init 时使用
///
/// 清除内存中的域名列表和最快域名,不关闭 HttpClient(复用连接池)。
/// 不删除磁盘缓存(缓存代表最近已知可用状态,跨 init 保留)。
void reset() {
_generation++; // 使所有进行中的测速结果失效
_fastestDomain = null;
_reportDomains = [];
onFastestDomainChanged = null; // 防止旧回调在新一轮测速前残留
Logger.domainManager('域名管理器状态已重置');
}
/// 释放 HttpClient 资源,通常在 SDK dispose 时调用
void dispose() {
_httpClient?.close();
_httpClient = null;
Logger.domainManager('域名管理器已销毁');
}
/// 从磁盘加载上次缓存的域名列表
///
/// 返回非空列表时可直接传入 [initWithDomains]。
/// 无缓存文件或读取失败时返回空列表(不抛出异常)。
Future<List<String>> loadCachedDomains() async {
try {
final content =
await PlatformStorage.read(SdkConfig.domainCacheFileName);
if (content == null) return [];
final decoded = jsonDecode(content);
if (decoded is List) {
return (decoded as List)
.map<String>((item) => item.toString().trim())
.where((d) => d.isNotEmpty)
.toList();
}
return [];
} catch (e) {
Logger.domainManager('加载域名缓存失败: $e');
return [];
}
}
// ==================== 私有方法 ====================
/// 将当前 _reportDomains 写入磁盘缓存(fire-and-forget)
void _saveDomainCache() {
if (_reportDomains.isEmpty) return;
final domainsSnapshot = List<String>.from(_reportDomains);
Future(() async {
try {
await PlatformStorage.write(
SdkConfig.domainCacheFileName,
jsonEncode(domainsSnapshot),
);
Logger.domainManager('域名缓存已写入: $domainsSnapshot');
} catch (e) {
Logger.domainManager('写入域名缓存失败: $e');
}
});
}
/// 对所有域名进行并发测速,返回最快的域名
Future<String?> _speedTestAndSelect(List<String> domains) async {
if (domains.isEmpty) return null;
final speedResults = <String, Duration>{};
final futures = domains.map((domain) async {
try {
final speed = await _speedTest(domain);
if (speed != null) {
speedResults[domain] = speed;
Logger.domainManager('域名 $domain 测速: ${speed.inMilliseconds}ms');
}
} catch (e) {
Logger.domainManager('域名 $domain 测速失败: $e');
}
});
await Future.wait(futures);
if (speedResults.isEmpty) {
Logger.domainManager('所有域名测速失败,回退到使用第一个域名作为上报域名',
level: LogLevel.warn);
return domains.first;
}
final fastest =
speedResults.entries.reduce((a, b) => a.value < b.value ? a : b);
Logger.domainManager(
'最快域名: ${fastest.key} (${fastest.value.inMilliseconds}ms)');
return fastest.key;
}
/// 测速单个域名,返回连接耗时;连接超时或网络异常返回 null
///
/// 仅 HTTP 200 视为可达。
/// 非 200(3xx 重定向、4xx 客户端错误、5xx 服务端错误)/ 连接失败 / 超时 视为不可达,返回 null。
Future<Duration?> _speedTest(String domain) async {
try {
final uri = Uri.parse(domain);
final startTime = DateTime.now();
final response =
await _client.get(uri).timeout(SdkConfig.speedTestTimeout);
final elapsed = DateTime.now().difference(startTime);
if (response.statusCode != 200) {
Logger.domainManager(
'域名 $domain 返回 ${response.statusCode},视为不可达',
level: LogLevel.warn);
return null;
}
Logger.domainManager(
'域名 $domain 可达,状态码: ${response.statusCode}');
return elapsed;
} catch (e) {
Logger.domainManager('域名 $domain 测速失败: $e', level: LogLevel.warn);
return null;
}
}
}