feat: improve desktop path selection and USB connection recovery

This commit is contained in:
tongtong committed 2026-11-13 03:14:00 +08:00
1 parent 5aa575f182
commit 6490665af8
28 files changed
+846 -51

No files matched your search

+43 -1
View File
@@ -7,6 +7,7 @@ Future<void> main(List<String> args) async {
try {
await repo.init();
repo.settings.usbMode = args.contains('--usb');
repo.settings.relayOnly = args.contains('--relay-only');
final devices = await repo.devices();
stdout.writeln(
'API devices: ${devices.map((d) => "${d.id} busy=${d.busy}").join(", ")}',
@@ -23,6 +24,7 @@ Future<void> main(List<String> args) async {
return;
}
final s = await repo.connect(device.id);
s.screenPageVisible = true;
for (var i = 0; i < 20 && !s.ready && !s.exited; i++) {
await Future<void>.delayed(const Duration(seconds: 3));
await repo.monitor();
@@ -34,13 +36,53 @@ Future<void> main(List<String> args) async {
'Remote model: ${await repo.run(s.adb, ['-s', s.endpoint, 'shell', 'getprop', 'ro.product.model'])}',
);
if (args.contains('--screen')) {
await repo.screen(s);
await repo.screen(s, embedded: args.contains('--embedded'));
await Future<void>.delayed(const Duration(seconds: 8));
if (s.screen == null) {
throw StateError('scrcpy exited early');
}
stdout.writeln('scrcpy process alive: ${s.screen!.pid}');
}
if (args.contains('--recover')) {
final original = s.process.pid;
final oldBridge = s.usb!.bridge!.pid;
final wantedMode = s.screenEmbedded;
await repo.stop(s.process);
var recovered = false;
for (var i = 0; i < 80; i++) {
await Future<void>.delayed(const Duration(seconds: 1));
await repo.monitor();
if (!s.recovering &&
s.ready &&
s.process.pid != original &&
s.usb!.bridge!.pid != oldBridge &&
s.screen != null) {
recovered = true;
break;
}
}
if (!recovered) {
throw StateError(
'USB/client/screen automatic recovery did not complete: ${s.state}',
);
}
if (s.screenEmbedded != wantedMode) {
throw StateError('Screen mode was not preserved');
}
await Future<void>.delayed(const Duration(seconds: 8));
if (s.screen == null || !s.ready) {
throw StateError('Recovered screen did not remain running');
}
stdout.writeln('RECOVERY PASS: client + USB remount + scrcpy restored');
await repo.stopScreen(s);
for (var i = 0; i < 4; i++) {
await Future<void>.delayed(const Duration(seconds: 1));
await repo.monitor();
}
if (s.screen != null || s.screenWanted) {
throw StateError('Manual stop restarted screen');
}
}
if (args.contains('--usb')) {
final path = await repo.run(s.adb, ['-s', s.endpoint, 'get-devpath']);
// Windows ADB may return "unknown" for get-devpath. USB-only selection
@@ -0,0 +1,66 @@
import 'dart:io';
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:material_ui/material_ui.dart';
import 'package:ads_manager/ui/manager_model.dart';
import 'package:ads_manager/ui/manager_view.dart';
void main() {
for (final cancelled in [false, true]) {
testWidgets('file picker saves immediately; cancelled=$cancelled', (
tester,
) async {
tester.view.physicalSize = const Size(1280, 1800);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.resetPhysicalSize);
addTearDown(tester.view.resetDevicePixelRatio);
final folder = Directory.systemTemp.createTempSync('ads-path-test');
final model = ManagerModel();
model.repository.storage = folder;
try {
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SettingsView(
model: model,
chooseFile: (current, executable) async {
expect(executable, true);
return cancelled ? null : 'C:/SDK/adb.exe';
},
),
),
),
);
final buttons = find.byTooltip('选择文件并保存');
expect(buttons, findsNWidgets(5));
await tester.ensureVisible(buttons.at(2));
await tester.runAsync(() async {
await tester.tap(buttons.at(2));
for (
var i = 0;
i < 100 && !cancelled && model.notice != '文件位置已保存';
i++
) {
await Future<void>.delayed(const Duration(milliseconds: 20));
}
});
await tester.pumpAndSettle();
final file = File('${folder.path}/settings.json');
if (cancelled) {
expect(file.existsSync(), false);
} else {
expect(model.repository.settings.adb, 'C:/SDK/adb.exe');
final saved =
jsonDecode(file.readAsStringSync()) as Map<String, dynamic>;
expect(saved['adb'], 'C:/SDK/adb.exe');
expect(saved.containsKey('token'), false);
}
await tester.pumpWidget(const SizedBox());
model.dispose();
} finally {
folder.deleteSync(recursive: true);
}
});
}
}
+159
View File
@@ -0,0 +1,159 @@
import 'dart:async';
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:ads_manager/data/manager_repository.dart';
import 'package:ads_manager/data/windows_usb.dart';
import 'package:ads_manager/data/usb_recovery.dart';
class FakeProcess extends Fake implements Process {
final exit = Completer<int>();
@override
int get pid => 123;
@override
Future<int> get exitCode => exit.future;
@override
bool kill([ProcessSignal signal = ProcessSignal.sigterm]) {
if (!exit.isCompleted) {
exit.complete(-1);
}
return true;
}
}
class RecoveryRepo extends ManagerRepository {
RecoveryRepo() : super((_) {});
@override
void watch(Process process, String label) {}
String listing = '';
int remounts = 0, screens = 0;
bool? resumedEmbedded;
Completer<void>? hold;
@override
Future<String> run(String exe, List<String> args) async => listing;
@override
Future<void> recoverUsb(Session s) async {
remounts++;
if (hold != null) {
await hold!.future;
}
s.usbBroken = false;
}
@override
Future<Process> launchScreen(
String endpoint,
String adb,
String id, {
bool embedded = false,
}) async {
screens++;
resumedEmbedded = embedded;
return FakeProcess();
}
}
void main() {
test('embedded video waits for its page and visible main window', () async {
final repo = RecoveryRepo();
final s =
Session('phone', '127.0.0.1:15555', 'adb', 'missing', FakeProcess())
..usb = WindowsUsbSession('phone', 3240)
..initialized = true
..screenWanted = true
..screenEmbedded = true;
repo.sessions[s.id] = s;
repo.listing = '${s.endpoint}\tdevice\n';
await repo.monitor();
expect(repo.screens, 0);
s.screenPageVisible = true;
repo.allowEmbeddedResume = false;
await repo.monitor();
expect(repo.screens, 0);
repo.allowEmbeddedResume = true;
await repo.monitor();
expect(repo.screens, 1);
await repo.stopScreen(s);
});
test('requires three missed polls; ignores unauthorized and backs off', () {
final policy = UsbRecoveryPolicy();
final now = DateTime(2026);
expect(policy.due(now, ready: false), false);
expect(policy.due(now, ready: false), false);
expect(policy.due(now, ready: false), true);
policy.attempted(now);
expect(policy.due(now, ready: false, broken: true), false);
expect(
policy.due(
now.add(const Duration(seconds: 2)),
ready: false,
broken: true,
),
true,
);
expect(
policy.due(
now.add(const Duration(seconds: 30)),
ready: false,
unauthorized: true,
broken: true,
),
false,
);
for (var i = 0; i < 12; i++) {
policy.attempted(now);
}
expect(policy.retryAt.difference(now).inSeconds, 30);
});
test('one remount task at a time, then resumes the requested mode', () async {
final repo = RecoveryRepo();
final session =
Session('phone', '127.0.0.1:15555', 'adb', 'missing', FakeProcess())
..usb = WindowsUsbSession('phone', 3240)
..initialized = true
..screenWanted = true
..screenPageVisible = true
..screenEmbedded = true;
repo.sessions[session.id] = session;
repo.hold = Completer<void>();
for (var i = 0; i < 5; i++) {
await repo.monitor();
}
expect(repo.remounts, 1);
expect(session.recovering, true);
repo.hold!.complete();
await session.recoveryTask;
session.recovery.retryAt = DateTime(2026);
repo.listing = '${session.endpoint}\tdevice\n';
await repo.monitor();
expect(repo.screens, 1);
expect(repo.resumedEmbedded, true);
expect(session.screenWanted, true);
await repo.stopScreen(session);
await repo.monitor();
expect(repo.screens, 1);
expect(session.screenWanted, false);
});
test('stopping a session prevents remount and screen restart', () async {
final repo = RecoveryRepo();
final session =
Session('phone', '127.0.0.1:15555', 'adb', 'missing', FakeProcess())
..usb = WindowsUsbSession('phone', 3240)
..initialized = true
..stopping = true;
repo.sessions[session.id] = session;
for (var i = 0; i < 5; i++) {
await repo.monitor();
}
await repo.screen(session, embedded: true);
expect(repo.remounts, 0);
expect(repo.screens, 0);
expect(session.screenWanted, false);
});
test('path settings persist paths, not credential contents', () {
final settings = Settings()
..agentPaths = {'admin': 'C:/admin.env', 'configPath': 'C:/agent.json'};
final loaded = Settings()..load(settings.toJson());
expect(loaded.agentPaths, settings.agentPaths);
});
}