初始化

This commit is contained in:
谢宇宁
2026-09-15 15:44:13 +07:00
commit a23ba685e9
1065 changed files with 101122 additions and 0 deletions
+323
View File
@@ -0,0 +1,323 @@
import 'dart:convert';
import 'dart:io';
import 'package:crypto/crypto.dart';
import 'package:device_identity/device_identity.dart';
import 'package:device_info_plus/device_info_plus.dart';
import 'package:flutter/services.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:hgdj/extension/extensions.dart';
import 'package:package_info_plus/package_info_plus.dart';
import 'package:path_provider/path_provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:uuid/uuid.dart';
import '../config/config.dart';
import '../hj_utils/light_model.dart';
import '../hj_utils/store_keys.dart';
import '../hj_utils/text_util.dart';
//设备信息管理类
class DeviceInfoService {
/// iOS Keychain 存 DevID。同一个 bundle id 卸载重装后 Keychain 项仍然存在(iOS
/// 沙盒清理不动 Keychain) → 同账号身份。**没声明 Keychain Sharing access group
/// 不同 bundle id 马甲互相读不到对方的 DevID(各自独立),这是产品取舍。**
static const _kKeychainDevIdKey = 'hgdj_device_id_v1';
static const _secureStorage = FlutterSecureStorage(
iOptions: IOSOptions(
accessibility: KeychainAccessibility.first_unlock,
),
);
static final DeviceInfoPlugin _infoPlugin = DeviceInfoPlugin();
static String? _brand;
static String? _model;
static String? _deviceId;
static String? _deviceOS;
static String? _systemVersion;
static String? _devType;
static String? _ua;
static String? _buildID;
//剪切板缓存(iOS 每次读取会弹系统提示,全局只读一次;缓存 Future 防并发重复触发)
static Future<String?>? _clipboardFuture;
/// 获取剪切板文本,全局只触发一次系统读取
static Future<String?> getClipboardTextCached() {
return _clipboardFuture ??= _readClipboardOnce();
}
static Future<String?> _readClipboardOnce() async {
try {
final data = await Clipboard.getData(Clipboard.kTextPlain);
return data?.text;
} catch (_) {
return null;
}
}
/// 获取品牌
static String get brand => _brand ?? "";
/// 获取型号
static String get model => _model ?? "";
/// 设备唯一 ID(APP 内保持不变)
static String get deviceId => _deviceId ?? "";
/// 设备平台
static String get deviceOS => _deviceOS ?? "";
//系统版本
static String get systemVersion => _systemVersion ?? "";
//拼接参数
static String get devType => _devType ?? "";
static String get ua => _ua ?? "";
/// 修正后的 pkgNameiOS 用 TF 内部包名常量,Android 用真实包名
static String get buildID => _buildID ?? "";
/// ios tf 的内部包名
/// note_this:不要修改这个值
static const iosBundleId = "yinse_opera";
static const naticeChannel = 'com.yinse/device'; //原生通道(设备/视频/编解码信息)
static const requestChannel =
'com.yinse/request'; //原生系统桥(现只剩换启动图标 changeIcon)
/// 外部调用入口
static Future<void> init() async {
// buildID 初始化一次,后续都用缓存
if (Platform.isIOS) {
_buildID = iosBundleId;
} else {
final pkg = await PackageInfo.fromPlatform();
_buildID = pkg.packageName;
}
// 设备ID:多重持久化(SP + 私有目录文件),任一存在即复用
_deviceId = await _resolveDeviceId();
if (Platform.isAndroid) {
final android = await _infoPlugin.androidInfo;
_brand = android.brand;
_model = android.model;
_deviceOS = "Android";
_systemVersion = android.version.release;
_devType = "${android.device}:${android.version.sdkInt}:id=${android.id}";
} else if (Platform.isIOS) {
final ios = await _infoPlugin.iosInfo;
_brand = "Apple";
_model = ios.utsname.machine; // 如 iPhone14,2
_deviceOS = "iOS";
_systemVersion = ios.utsname.release;
_devType = "${ios.systemName}:$_systemVersion";
} else {
_brand = "Unknown";
_model = "Unknown";
_deviceOS = Platform.operatingSystem;
_systemVersion = 'Unknown';
}
_ua = genUserAgent();
}
/// 拼装 UA。[deviceId] 可覆盖默认 deviceId
static String genUserAgent({String? deviceId}) {
final Map<String, String?> params = {
"DevID": (deviceId == null || deviceId.isEmpty)
? DeviceInfoService.deviceId
: deviceId,
"DevType": DeviceInfoService.devType,
"SysType": Platform.operatingSystem,
"Ver": Config.innerVersion,
"BuildID": DeviceInfoService.buildID,
'DeviceBrand': DeviceInfoService.brand,
'SystemName': DeviceInfoService.deviceOS,
'SystemVersion': DeviceInfoService.systemVersion,
'device_model': DeviceInfoService.model,
};
params.removeWhere((key, value) => value == null || value.isEmpty);
final ua = Uri.encodeComponent(
params.entries.map((e) => "${e.key}=${e.value}").join(";"));
return ua;
}
/// 获取带缓存的 UA。
/// - [deviceId] 为空:命中 KV 缓存直接返回;
/// - [deviceId] 非空:跳过缓存,按当前最新设备信息重新生成并写回 KV(用于扫码登录、设备切换等场景)。
/// 实际写入 UA 的 DevID 字段:deviceId 非空用它,否则 fallback 到 [DeviceInfoService.deviceId]。
static Future<String> getCachedUserAgent({String? deviceId}) async {
final oldUa = (await lightKV.getString(StoreKeys.UA_CACHE)) ?? '';
if (TextUtil.isEmpty(deviceId) && TextUtil.isNotEmpty(oldUa)) {
return oldUa;
}
final newUa = genUserAgent(deviceId: deviceId);
if (TextUtil.isNotEmpty(newUa))
lightKV.setString(StoreKeys.UA_CACHE, newUa);
return newUa;
}
/// 清除 UA 缓存
static Future clearCachedUserAgent() =>
lightKV.setString(StoreKeys.UA_CACHE, null);
/// 从剪切板 json 里取推广 tid,取不到返回空串
static Future<String> fetchTraceId() async {
final clipboardText = await getClipboardTextCached();
if (TextUtil.isEmpty(clipboardText)) return '';
try {
return jsonDecode(clipboardText!)['tid'] ?? '';
} catch (_) {
return '';
}
}
/// 已知 ANDROID_ID 脏值(厂商定制 ROM / 早期山寨机长期出现)
static const _dirtyAndroidIds = <String>{
'9774d56d682e549c', // Android 4.2 之前山寨机著名脏值
'0000000000000000',
'ffffffffffffffff',
'0123456789abcdef',
};
/// 解析设备 ID:按平台分两条独立路径,任一命中都回写到该平台的所有存储层。
///
/// iOS Keychain 是唯一**跨卸载 + 跨 bundle id** 持久的存储(配合 Keychain Sharing)。
/// SP/文件在 app 沙盒里,卸载就抹;放最高优先级用 Keychain 才能保住账号身份。
/// Android 没有等价机制,applicationId 一变就是新 app,账号无法共享(产品取舍)。
static Future<String> _resolveDeviceId() async {
final prefs = await SharedPreferences.getInstance();
return Platform.isIOS ? _resolveIOS(prefs) : _resolveAndroid(prefs);
}
/// iOSKeychain → SP → 文件 → 新生成,命中即回写三层(Keychain+SP+文件)
static Future<String> _resolveIOS(SharedPreferences prefs) async {
// 1. Keychain 优先(卸载重装、马甲切换都能拿到原 DevID)
try {
final kid = await _secureStorage.read(key: _kKeychainDevIdKey);
if (TextUtil.isNotEmpty(kid)) return _persistIOS(prefs, kid!);
} catch (_) {
// Keychain 偶发失败不阻塞启动,继续走 SP/文件兜底
}
// 2. SP 命中
final spId = prefs.getString(StoreKeys.DEVICE_ID);
if (TextUtil.isNotEmpty(spId)) return _persistIOS(prefs, spId!);
// 3. 文件命中
final fileId = await _readIdFile();
if (TextUtil.isNotEmpty(fileId)) return _persistIOS(prefs, fileId!);
// 4. 全新生成
return _persistIOS(prefs, await _generateDeviceId());
}
/// Android:SP → 文件 → 新生成,命中即回写两层(SP+文件),无 Keychain 等价机制
static Future<String> _resolveAndroid(SharedPreferences prefs) async {
// 1. SP 命中
final spId = prefs.getString(StoreKeys.DEVICE_ID);
if (TextUtil.isNotEmpty(spId)) return _persistAndroid(prefs, spId!);
// 2. 文件命中
final fileId = await _readIdFile();
if (TextUtil.isNotEmpty(fileId)) return _persistAndroid(prefs, fileId!);
// 3. 全新生成
return _persistAndroid(prefs, await _generateDeviceId());
}
/// iOS 回写三层,保证 Keychain/SP/文件一致
static Future<String> _persistIOS(SharedPreferences prefs, String id) async {
await prefs.setString(StoreKeys.DEVICE_ID, id);
await _writeIdFile(id);
await _trySaveKeychain(id);
return id;
}
/// Android 回写 SP + 文件
static Future<String> _persistAndroid(
SharedPreferences prefs, String id) async {
await prefs.setString(StoreKeys.DEVICE_ID, id);
await _writeIdFile(id);
return id;
}
/// 写 Keychain 失败不抛错(权限/entitlements 配错时降级走 SP+文件,不卡启动)
static Future<void> _trySaveKeychain(String id) async {
try {
await _secureStorage.write(key: _kKeychainDevIdKey, value: id);
} catch (_) {}
}
/// 生成新设备 ID
/// AndroidOAID → ANDROID_ID → UUID 兜底
/// iOSidentifierForVendorIDFV)→ UUID 兜底
static Future<String> _generateDeviceId() async {
String raw = '';
if (Platform.isAndroid) {
try {
await DeviceIdentity.register();
raw = await DeviceIdentity.oaid;
if (_isInvalidId(raw)) {
raw = await DeviceIdentity.androidId;
}
} catch (_) {}
} else if (Platform.isIOS) {
try {
final ios = await _infoPlugin.iosInfo;
raw = ios.identifierForVendor ?? '';
} catch (_) {}
}
if (_isInvalidId(raw)) raw = const Uuid().v4();
// 业务规则:hgdj_ 前缀,去空格,限制 50 字符(日志系统约束)
return 'hgdj_${raw.replaceAll(' ', '')}'.limit(50);
}
/// 脏值检测:空 / 太短 / 全 0 / 已知脏值
static bool _isInvalidId(String? id) {
if (TextUtil.isEmpty(id)) return true;
final v = id!.toLowerCase();
if (v.length < 8) return true;
if (v.hasManyZeros()) return true;
return _dirtyAndroidIds.contains(v);
}
/// 写入应用支持目录文件(零权限,卸载会丢,但与 SP 互为冗余)
static Future<void> _writeIdFile(String id) async {
try {
final dir = await getApplicationSupportDirectory();
final file = File('${dir.path}/.device_id');
await file.writeAsString(id, flush: true);
} catch (_) {}
}
/// 读取应用支持目录文件
static Future<String?> _readIdFile() async {
try {
final dir = await getApplicationSupportDirectory();
final file = File('${dir.path}/.device_id');
if (!await file.exists()) return null;
final v = (await file.readAsString()).trim();
return v.isEmpty ? null : v;
} catch (_) {
return null;
}
}
/// 获取加密后的设备id验签
static String getDevToken(String devId) {
String a = "g24p5VJ4fJ";
String b = "5P#at%Yu";
String c = "ZPRwQuKl8YlVIr";
String s = a + b + c + devId + a + b + c;
var data = utf8.encode(s);
var chiper = sha256.convert(data);
return base64Encode(chiper.bytes);
}
///获取渠道(非 Android 或取不到都返回空串)
static Future<String> getChannel() async {
if (!Platform.isAndroid) return "";
try {
return await const MethodChannel(naticeChannel)
.invokeMethod("getChannel") ??
"";
} on PlatformException {
return "";
}
}
}
@@ -0,0 +1,95 @@
import 'package:hgdj/hj_utils/light_model.dart';
import 'package:hgdj/hj_utils/store_keys.dart';
import 'package:uuid/uuid.dart';
/// 会话管理器 - 生成并维护统一的会话 ID (sid)
///
/// 会话 = 用户一次连续使用产生的一组行为,同一会话内所有请求/埋点共享同一个 sid。
///
/// 会话重建规则(满足任一即换新 sid):
/// 1. App 冷启动
/// 2. 从后台回前台,且后台停留 > 30 分钟
/// 3. 从后台回前台,且距会话创建 > 30 分钟
///
/// 持久化在 MMKV (lightKV):当前 sid / 会话创建时间 / 进入后台时间
class TrackSessionManager {
static final TrackSessionManager _instance = TrackSessionManager._();
factory TrackSessionManager() => _instance;
TrackSessionManager._();
/// 会话超时阈值:30 分钟
static const Duration _timeout = Duration(minutes: 30);
String _sid = '';
DateTime? _sessionAt; //会话创建时间
DateTime? _backgroundedAt; //App 进入后台的时间
bool _inited = false;
/// 当前会话 ID,为空则立即新建(防御性)
String get currentSid {
if (_sid.isEmpty) _newSession();
return _sid;
}
/// App 冷启动时调用一次(main.dart):恢复旧状态后强制开新会话
Future<void> onAppColdStart() async {
if (_inited) return;
await _restore();
_newSession();
}
/// App 进入后台:记录时刻,用于回前台时判断停留时长
/// 调用时机:AppLifecycleState.paused / inactive / detached
Future<void> onAppPause() async {
_backgroundedAt = DateTime.now();
await lightKV.setInt(StoreKeys.TRACK_SESSION_BACKGROUND_TS,
_backgroundedAt!.millisecondsSinceEpoch);
}
/// App 回到前台:后台停留超时或会话本身超时都换新 sid(规则2、3)
/// 调用时机:AppLifecycleState.resumed
Future<void> onAppResume() async {
//没进过后台不算规则2,所以要先判非空
final bgExpired = _backgroundedAt != null && _isExpired(_backgroundedAt);
if (bgExpired || _isExpired(_sessionAt)) _newSession();
_backgroundedAt = null;
await lightKV.setInt(StoreKeys.TRACK_SESSION_BACKGROUND_TS, 0);
}
/// 从存储恢复上次的 sid 和时间戳,已过期则先开新会话
Future<void> _restore() async {
_sid = (await lightKV.getString(StoreKeys.TRACK_SESSION_SID)) ?? '';
//键名沿用历史的 LAST_EVENT_TS,存的是会话创建时间
final sessionTs =
await lightKV.getInt(StoreKeys.TRACK_SESSION_LAST_EVENT_TS);
if (sessionTs != null && sessionTs > 0)
_sessionAt = DateTime.fromMillisecondsSinceEpoch(sessionTs);
final backgroundTs =
await lightKV.getInt(StoreKeys.TRACK_SESSION_BACKGROUND_TS);
if (backgroundTs != null && backgroundTs > 0)
_backgroundedAt = DateTime.fromMillisecondsSinceEpoch(backgroundTs);
if (_sid.isEmpty || _isExpired(_sessionAt)) _newSession();
_inited = true;
}
/// 距 [time] 是否已超过 30 分钟(time 为空按已过期处理)
bool _isExpired(DateTime? time) {
if (time == null) return true;
return DateTime.now().difference(time) > _timeout;
}
/// 新建会话并立即落盘,防止进程被杀丢数据
void _newSession() {
_sid = Uuid().v4().replaceAll('-', '');
_sessionAt = DateTime.now();
lightKV.setString(StoreKeys.TRACK_SESSION_SID, _sid);
lightKV.setInt(StoreKeys.TRACK_SESSION_LAST_EVENT_TS,
_sessionAt!.millisecondsSinceEpoch);
}
}