611 lines
17 KiB
Dart
611 lines
17 KiB
Dart
import 'dart:async';
|
||
import 'dart:convert';
|
||
import 'dart:io';
|
||
|
||
import 'package:path/path.dart' as p;
|
||
|
||
import 'windows_usb.dart';
|
||
|
||
class Settings {
|
||
String server = 'wss://ttstd.com/ads';
|
||
String origin = '175.178.213.60:443';
|
||
String credential = '';
|
||
String client = '', adb = '', scrcpy = '';
|
||
bool relayOnly = false, usbMode = false;
|
||
String usbip = UsbDriver.defaultUsbip();
|
||
Map<String, dynamic> toJson() => {
|
||
'server': server,
|
||
'origin': origin,
|
||
'credential': credential,
|
||
'client': client,
|
||
'adb': adb,
|
||
'scrcpy': scrcpy,
|
||
'relayOnly': relayOnly,
|
||
'usbMode': usbMode,
|
||
'usbip': usbip,
|
||
};
|
||
void load(Map<String, dynamic> j) {
|
||
server = j['server'] as String? ?? server;
|
||
origin = j['origin'] as String? ?? origin;
|
||
credential = j['credential'] as String? ?? credential;
|
||
client = j['client'] as String? ?? client;
|
||
adb = j['adb'] as String? ?? adb;
|
||
scrcpy = j['scrcpy'] as String? ?? scrcpy;
|
||
relayOnly = j['relayOnly'] == true;
|
||
usbMode = j['usbMode'] == true;
|
||
usbip = j['usbip'] as String? ?? usbip;
|
||
}
|
||
|
||
Uri uri(String suffix) {
|
||
final u = Uri.parse(server.trim());
|
||
if (u.scheme != 'wss' ||
|
||
u.host.isEmpty ||
|
||
u.hasQuery ||
|
||
u.hasFragment ||
|
||
u.userInfo.isNotEmpty) {
|
||
throw const FormatException('服务地址必须是有效的 wss:// 地址');
|
||
}
|
||
return u.replace(
|
||
scheme: 'https',
|
||
path: '${u.path.replaceFirst(RegExp(r"/+$"), "")}/$suffix',
|
||
);
|
||
}
|
||
}
|
||
|
||
class Device {
|
||
final String id;
|
||
final bool busy;
|
||
const Device(this.id, this.busy);
|
||
}
|
||
|
||
class Session {
|
||
final String id, tunnel, adb, statusFile;
|
||
String? leaseFile;
|
||
WindowsUsbSession? usb;
|
||
String get endpoint => usb?.serial ?? tunnel;
|
||
String get mode => usb == null ? "网络 ADB" : "虚拟 USB";
|
||
final Process process;
|
||
Process? screen;
|
||
bool screenEmbedded = false;
|
||
String state = '连接中', route = '协商中';
|
||
bool ready = false, stopping = false, exited = false;
|
||
Session(this.id, this.tunnel, this.adb, this.statusFile, this.process);
|
||
}
|
||
|
||
class ManagerRepository {
|
||
final Settings settings = Settings();
|
||
final Map<String, Session> sessions = {};
|
||
final Set<int> reservedPorts = {};
|
||
final void Function(String) log;
|
||
String token = '';
|
||
Directory? root;
|
||
late Directory storage;
|
||
ManagerRepository(this.log);
|
||
|
||
Future<void> init() async {
|
||
storage = Directory(
|
||
p.join(
|
||
Platform.environment['LOCALAPPDATA'] ?? Directory.systemTemp.path,
|
||
'TTSTD',
|
||
'ADS-Flutter',
|
||
),
|
||
);
|
||
await storage.create(recursive: true);
|
||
for (final start in [
|
||
Directory.current.path,
|
||
p.dirname(Platform.resolvedExecutable),
|
||
]) {
|
||
var d = Directory(start);
|
||
while (true) {
|
||
if (File(p.join(d.path, 'Cargo.toml')).existsSync()) {
|
||
root = d;
|
||
break;
|
||
}
|
||
final parent = d.parent;
|
||
if (parent.path == d.path) {
|
||
break;
|
||
}
|
||
d = parent;
|
||
}
|
||
if (root != null) {
|
||
break;
|
||
}
|
||
}
|
||
settings.client = findTool('ads-client');
|
||
settings.adb = findTool('adb');
|
||
settings.scrcpy = findTool('scrcpy');
|
||
settings.credential = root == null
|
||
? ''
|
||
: p.join(root!.path, 'config', 'private', 'client.env');
|
||
final saved = File(p.join(storage.path, 'settings.json'));
|
||
if (await saved.exists()) {
|
||
settings.load(
|
||
jsonDecode(await saved.readAsString()) as Map<String, dynamic>,
|
||
);
|
||
}
|
||
token = Platform.environment['ADS_CLIENT_TOKEN'] ?? '';
|
||
if (token.isEmpty && await File(settings.credential).exists()) {
|
||
await importCredential();
|
||
}
|
||
}
|
||
|
||
String findTool(String name) {
|
||
final exe = '$name.exe';
|
||
final base = p.dirname(Platform.resolvedExecutable);
|
||
final candidates = [
|
||
p.join(base, exe),
|
||
p.join(base, 'tools', 'scrcpy', exe),
|
||
if (root != null) p.join(root!.path, 'bin', exe),
|
||
if (root != null) p.join(root!.path, 'bin', 'tools', 'scrcpy', exe),
|
||
for (final dir in (Platform.environment['PATH'] ?? '').split(';'))
|
||
p.join(dir, exe),
|
||
];
|
||
return candidates.firstWhere(
|
||
(v) => File(v).existsSync(),
|
||
orElse: () => exe,
|
||
);
|
||
}
|
||
|
||
Future<void> save() =>
|
||
File(p.join(storage.path, 'settings.json'))
|
||
.writeAsString(jsonEncode(settings.toJson()));
|
||
Future<void> importCredential() async {
|
||
final file = File(settings.credential);
|
||
if (await file.length() > 65536) {
|
||
throw const FormatException('凭据文件过大');
|
||
}
|
||
final values = <String, String>{};
|
||
for (final line in await file.readAsLines()) {
|
||
final i = line.indexOf('=');
|
||
if (i > 0) {
|
||
values[line.substring(0, i).trim()] = line.substring(i + 1).trim();
|
||
}
|
||
}
|
||
final value = values['ADS_CLIENT_TOKEN'] ?? '';
|
||
if (value.length < 32 || value.contains(RegExp(r'[\r\n]'))) {
|
||
throw const FormatException('请选择包含 ADS_CLIENT_TOKEN 的 client.env');
|
||
}
|
||
token = value;
|
||
if (values['ADS_CONNECT_ADDRESS'] case final String address) {
|
||
settings.origin = address;
|
||
}
|
||
}
|
||
|
||
Future<dynamic> get(String suffix) => requestJson(suffix);
|
||
|
||
Future<dynamic> requestJson(
|
||
String suffix, {
|
||
String? bearer,
|
||
Map<String, Object?>? payload,
|
||
Map<String, String>? query,
|
||
}) async {
|
||
final authorization = bearer ?? token;
|
||
if (authorization.length < 32) {
|
||
throw FormatException(
|
||
bearer == null ? '请先导入客户端凭据' : '请先导入管理员凭据 admin.env',
|
||
);
|
||
}
|
||
final client = HttpClient()..connectionTimeout = const Duration(seconds: 8);
|
||
client.findProxy = (_) => 'DIRECT';
|
||
if (settings.origin.trim().isNotEmpty) {
|
||
final origin = Uri.parse('tcp://${settings.origin.trim()}');
|
||
if (origin.host.isEmpty ||
|
||
!origin.hasPort ||
|
||
origin.port < 1 ||
|
||
origin.port > 65535) {
|
||
throw const FormatException('直连地址应为 IP或主机名:端口');
|
||
}
|
||
client.connectionFactory = (uri, proxyHost, proxyPort) async {
|
||
final task = await Socket.startConnect(origin.host, origin.port);
|
||
Socket? connected;
|
||
final secured = task.socket
|
||
.then((socket) async {
|
||
connected = socket;
|
||
return SecureSocket.secure(socket, host: uri.host);
|
||
})
|
||
.then((socket) {
|
||
connected = socket;
|
||
return socket;
|
||
});
|
||
return ConnectionTask.fromSocket(secured, () {
|
||
task.cancel();
|
||
connected?.destroy();
|
||
});
|
||
};
|
||
}
|
||
try {
|
||
final uri = settings.uri(suffix).replace(queryParameters: query);
|
||
final request = payload == null
|
||
? await client.getUrl(uri)
|
||
: await client.postUrl(uri);
|
||
request.followRedirects = false;
|
||
request.headers.set('Authorization', 'Bearer $authorization');
|
||
if (payload != null) {
|
||
request.headers.contentType = ContentType.json;
|
||
request.write(jsonEncode(payload));
|
||
}
|
||
final response = await request.close().timeout(
|
||
const Duration(seconds: 12),
|
||
);
|
||
final body = await utf8.decoder
|
||
.bind(response)
|
||
.join()
|
||
.timeout(const Duration(seconds: 12));
|
||
if (suffix == 'v2/nodes' && response.statusCode == 404) {
|
||
return {'nodes': <dynamic>[]};
|
||
}
|
||
if (response.statusCode != 200) {
|
||
throw HttpException('控制中心 HTTP ${response.statusCode}');
|
||
}
|
||
return jsonDecode(body);
|
||
} finally {
|
||
client.close(force: true);
|
||
}
|
||
}
|
||
|
||
Future<List<Device>> devices() async {
|
||
final raw = await get('v1/devices') as List<dynamic>;
|
||
return raw.map((v) {
|
||
final j = v as Map<String, dynamic>;
|
||
final id = j['id'] as String;
|
||
if (!RegExp(r'^[a-zA-Z0-9_.-]{1,128}$').hasMatch(id)) {
|
||
throw const FormatException('无效设备 ID');
|
||
}
|
||
return Device(id, j['busy'] == true);
|
||
}).toList()..sort((a, b) => a.id.compareTo(b.id));
|
||
}
|
||
|
||
Map<String, String> environment() => Map.of(Platform.environment)
|
||
..removeWhere(
|
||
(k, v) => [
|
||
'ADB_SERVER_SOCKET',
|
||
'ANDROID_ADB_SERVER_ADDRESS',
|
||
'ANDROID_ADB_SERVER_PORT',
|
||
'ADS_CLIENT_TOKEN',
|
||
'ADS_AGENT_TOKEN',
|
||
'ADS_ADMIN_TOKEN',
|
||
'ADS_CONNECT_ADDRESS',
|
||
].contains(k),
|
||
)
|
||
..['NO_COLOR'] = '1';
|
||
|
||
Future<String> run(String exe, List<String> args) async {
|
||
final proc = await Process.start(
|
||
exe,
|
||
args,
|
||
environment: environment(),
|
||
includeParentEnvironment: false,
|
||
);
|
||
final out = utf8.decoder.bind(proc.stdout).join();
|
||
final err = utf8.decoder.bind(proc.stderr).join();
|
||
try {
|
||
final code = await proc.exitCode.timeout(const Duration(seconds: 12));
|
||
final output = await out, error = await err;
|
||
if (code != 0) {
|
||
throw ProcessException(p.basename(exe), [], error, code);
|
||
}
|
||
return output;
|
||
} on TimeoutException {
|
||
proc.kill();
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
void watch(Process proc, String label) {
|
||
for (final stream in [proc.stdout, proc.stderr]) {
|
||
stream
|
||
.transform(const Utf8Decoder(allowMalformed: true))
|
||
.transform(const LineSplitter())
|
||
.listen(
|
||
(line) => log(
|
||
'[$label] ${token.isEmpty ? line : line.replaceAll(token, "[REDACTED]")}',
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
Future<Session> connect(String id) async {
|
||
if (sessions.containsKey(id)) {
|
||
return sessions[id]!;
|
||
}
|
||
settings.uri('v1/devices');
|
||
if (token.length < 32) {
|
||
throw const FormatException('请先导入凭据');
|
||
}
|
||
final usbMode = settings.usbMode;
|
||
final usbip = settings.usbip;
|
||
if (usbMode) {
|
||
if (!await UsbDriver.installed(run)) {
|
||
throw StateError('未安装 USBip 虚拟控制器,请在连接配置中安装驱动');
|
||
}
|
||
if (!await File(usbip).exists()) {
|
||
throw StateError('找不到 usbip.exe,请检查配置路径');
|
||
}
|
||
await run(findTool('ads-usb'), ['--version']);
|
||
}
|
||
final port = await allocatePort(15555, 18000);
|
||
int? usbPort;
|
||
Session? session;
|
||
try {
|
||
if (usbMode) {
|
||
usbPort = await allocateUsbPort();
|
||
}
|
||
final endpoint = '127.0.0.1:$port';
|
||
final status = p.join(
|
||
storage.path,
|
||
'transport-$id-${DateTime.now().microsecondsSinceEpoch}.json',
|
||
);
|
||
final lease = usbMode ? "$status.lease" : null;
|
||
final proc = await Process.start(
|
||
settings.client,
|
||
[
|
||
'--server',
|
||
settings.server.trim(),
|
||
'--device',
|
||
id,
|
||
'--listen',
|
||
endpoint,
|
||
'--adb',
|
||
settings.adb,
|
||
'--transport',
|
||
settings.relayOnly ? 'relay' : 'auto',
|
||
'--status-file',
|
||
status,
|
||
if (lease != null) ...[
|
||
'--no-auto-connect',
|
||
'--lease-status-file',
|
||
lease,
|
||
],
|
||
if (settings.origin.trim().isNotEmpty) ...[
|
||
'--connect-address',
|
||
settings.origin.trim(),
|
||
],
|
||
],
|
||
environment: environment()..['ADS_CLIENT_TOKEN'] = token,
|
||
includeParentEnvironment: false,
|
||
);
|
||
watch(proc, id);
|
||
session = Session(id, endpoint, settings.adb, status, proc);
|
||
final current = session;
|
||
sessions[id] = current;
|
||
current.leaseFile = lease;
|
||
unawaited(
|
||
proc.exitCode.then((code) {
|
||
current.exited = true;
|
||
current.ready = false;
|
||
current.state = '连接程序已退出 ($code)';
|
||
}),
|
||
);
|
||
if (usbMode) {
|
||
final usb = WindowsUsbSession(id, usbPort!);
|
||
current.usb = usb;
|
||
current.state = '等待设备租约并挂载 USB';
|
||
await usb.start(
|
||
leaseFile: lease!,
|
||
upstream: current.tunnel,
|
||
executable: findTool('ads-usb'),
|
||
usbip: usbip,
|
||
environment: environment(),
|
||
run: run,
|
||
watch: watch,
|
||
cancelled: () => current.exited || current.stopping,
|
||
);
|
||
log('USB 已挂载:${usb.serial}');
|
||
}
|
||
return current;
|
||
} catch (_) {
|
||
if (session != null) {
|
||
await disconnect(id);
|
||
} else {
|
||
reservedPorts.remove(port);
|
||
if (usbPort != null) {
|
||
reservedPorts.remove(usbPort);
|
||
}
|
||
}
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
Future<int> allocateUsbPort() async {
|
||
// A new OS-selected endpoint also avoids a previous controller's delayed
|
||
// teardown reconnecting to the next export at a reused fixed port.
|
||
while (true) {
|
||
final probe = await ServerSocket.bind(InternetAddress.loopbackIPv4, 0);
|
||
final port = probe.port;
|
||
final reserved = reservedPorts.add(port);
|
||
await probe.close();
|
||
if (reserved) {
|
||
return port;
|
||
}
|
||
}
|
||
}
|
||
|
||
Future<int> allocatePort(int start, int end) async {
|
||
for (var port = start; port < end; port++) {
|
||
if (!reservedPorts.add(port)) {
|
||
continue;
|
||
}
|
||
try {
|
||
final probe = await ServerSocket.bind(
|
||
InternetAddress.loopbackIPv4,
|
||
port,
|
||
);
|
||
await probe.close();
|
||
return port;
|
||
} on SocketException {
|
||
reservedPorts.remove(port);
|
||
}
|
||
}
|
||
throw const SocketException('没有空闲的本地端口');
|
||
}
|
||
|
||
Future<void> monitor() async {
|
||
final listings = <String, String>{};
|
||
for (final s in sessions.values.toList()) {
|
||
if (!s.stopping && (s.exited || s.usb?.exited == true)) {
|
||
await disconnect(s.id);
|
||
continue;
|
||
}
|
||
if (s.stopping) {
|
||
continue;
|
||
}
|
||
try {
|
||
final listing = listings[s.adb] ??= await run(s.adb, ['devices', '-l']);
|
||
final rows = listing
|
||
.split('\n')
|
||
.map((r) => r.trim().split(RegExp(r'\s+')));
|
||
final row = rows
|
||
.where((r) => r.length >= 2 && r[0] == s.endpoint)
|
||
.firstOrNull;
|
||
s.ready = row?[1] == 'device';
|
||
s.state = row == null ? '等待设备 / 自动重连' : row[1];
|
||
final file = File(s.statusFile);
|
||
if (await file.exists()) {
|
||
final j =
|
||
jsonDecode(await file.readAsString()) as Map<String, dynamic>;
|
||
s.route =
|
||
'${j["transport"]} · ${(j["nodes"] as List<dynamic>? ?? []).join(", ")}';
|
||
}
|
||
} catch (e) {
|
||
s.ready = false;
|
||
s.state = '检测失败:$e';
|
||
}
|
||
}
|
||
}
|
||
|
||
Future<void> screen(Session s, {bool embedded = false}) async {
|
||
if (!s.ready) {
|
||
return;
|
||
}
|
||
if (s.screen != null) {
|
||
if (s.screenEmbedded == embedded) {
|
||
return;
|
||
}
|
||
await stop(s.screen);
|
||
s.screen = null;
|
||
}
|
||
final proc = await launchScreen(
|
||
s.endpoint,
|
||
s.adb,
|
||
s.id,
|
||
embedded: embedded,
|
||
);
|
||
s.screen = proc;
|
||
s.screenEmbedded = embedded;
|
||
watch(proc, 'scrcpy ${s.id}');
|
||
unawaited(
|
||
proc.exitCode.then((code) {
|
||
if (s.screen == proc) {
|
||
s.screen = null;
|
||
}
|
||
log('投屏窗口关闭 ($code)');
|
||
}),
|
||
);
|
||
}
|
||
|
||
Future<Process> launchScreen(
|
||
String endpoint,
|
||
String adb,
|
||
String id, {
|
||
bool embedded = false,
|
||
}) {
|
||
return Process.start(
|
||
settings.scrcpy,
|
||
[
|
||
'--serial',
|
||
endpoint,
|
||
'--force-adb-forward',
|
||
'--window-title',
|
||
'ADS Flutter · $id',
|
||
if (embedded) ...[
|
||
'--window-borderless',
|
||
'--hwdec=disabled',
|
||
'--render-driver=software',
|
||
'--no-window-aspect-ratio-lock',
|
||
],
|
||
'--max-size',
|
||
'1920',
|
||
'--max-fps',
|
||
'60',
|
||
'--no-audio',
|
||
],
|
||
workingDirectory: p.dirname(p.absolute(settings.scrcpy)),
|
||
environment: environment()..['ADB'] = adb,
|
||
includeParentEnvironment: false,
|
||
);
|
||
}
|
||
|
||
Future<void> stop(Process? proc) async {
|
||
if (proc == null) {
|
||
return;
|
||
}
|
||
proc.kill();
|
||
await proc.exitCode.timeout(const Duration(seconds: 5));
|
||
}
|
||
|
||
Future<void> disconnect(String id) async {
|
||
final s = sessions[id];
|
||
if (s == null || s.stopping) {
|
||
return;
|
||
}
|
||
s.stopping = true;
|
||
for (final proc in [s.screen, s.usb?.bridge, s.process]) {
|
||
try {
|
||
await stop(proc);
|
||
} catch (e) {
|
||
log('停止设备进程:$e');
|
||
}
|
||
}
|
||
try {
|
||
if (s.usb == null) {
|
||
await run(s.adb, ['disconnect', s.tunnel]);
|
||
} else {
|
||
final deadline = DateTime.now().add(const Duration(seconds: 8));
|
||
while (true) {
|
||
final listing = await run(s.adb, ['devices']);
|
||
if (!listing
|
||
.split('\n')
|
||
.any((line) => line.startsWith('${s.endpoint}\t'))) {
|
||
break;
|
||
}
|
||
if (DateTime.now().isAfter(deadline)) {
|
||
throw StateError('虚拟 USB 正在由 Windows 回收,请稍后重连');
|
||
}
|
||
await Future<void>.delayed(const Duration(milliseconds: 200));
|
||
}
|
||
}
|
||
} catch (e) {
|
||
log('断开 ADB:$e');
|
||
} finally {
|
||
sessions.remove(id);
|
||
reservedPorts.remove(int.parse(s.tunnel.split(':').last));
|
||
if (s.usb != null) {
|
||
reservedPorts.remove(s.usb!.port);
|
||
}
|
||
for (final path in [s.statusFile, s.leaseFile]) {
|
||
if (path == null) {
|
||
continue;
|
||
}
|
||
final file = File(path);
|
||
try {
|
||
if (await file.exists()) {
|
||
await file.delete();
|
||
}
|
||
} on FileSystemException catch (e) {
|
||
log('$e');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Future<void> shutdown() async {
|
||
for (final id in sessions.keys.toList()) {
|
||
try {
|
||
await disconnect(id);
|
||
} catch (e) {
|
||
log('释放 $id:$e');
|
||
}
|
||
}
|
||
}
|
||
}
|