"""设置页事件、ADB 搜索、Client 保存登记和软件更新。 本文件不直接写 SQL。ADB 搜索、SQLite 写入和 Admin HTTP 请求由 Worker 在线程中 执行；页面启动时只同步读取少量索引设置，后台结果通过信号返回主线程更新页面。 """ from typing import Optional from PyQt5.QtCore import ( QCoreApplication, QObject, QThread, QTimer, pyqtSignal, pyqtSlot, ) from .adb_runtime import BundledAdbError, validate_bundled_adb from .android_device_service import ( AndroidDeviceConversionCancelled, AndroidDeviceSearchError, AndroidDeviceSearchResult, AndroidDeviceService, PDD_PACKAGE_NAME, ) from .admin_gateway import ( AdminGatewayError, AndroidDeviceInfo, ClaimCapabilities, ClientInfo, ClientRegistrationGateway, ) from .current_client_service import ( CurrentClientService, generate_client_device_id, load_admin_base_url, ) from .http_admin_gateway import HttpAdminGateway from .selected_android_device_service import SelectedAndroidDeviceService from .settings_repository import SettingsRepository from .settings_ui import AndroidDeviceRow from .task_models import TaskType from .update_ui_event import UpdateUiEventBinder DEVICE_ID_PLACEHOLDER = "待生成" class CurrentClientSaveWorker(QObject): """在线程中先保存本地身份，再登记到 Admin。""" localSaved = pyqtSignal(str, str, str) localSaveFailed = pyqtSignal(str) registrationSucceeded = pyqtSignal(str) registrationFailed = pyqtSignal(str) completed = pyqtSignal() def __init__( self, service: CurrentClientService, gateway: Optional[ClientRegistrationGateway], client_name: str, capabilities: ClaimCapabilities, admin_base_url: str, gateway_error: str = "", ): super().__init__() self._service = service self._gateway = gateway self._client_name = client_name self._capabilities = capabilities self._admin_base_url = admin_base_url self._gateway_error = gateway_error self._cancelled = False def cancel(self) -> None: """阻止尚未开始的远端登记；已经发出的 HTTP 等超时返回。""" self._cancelled = True @pyqtSlot() def run(self) -> None: try: try: saved = self._service.save( self._client_name, self._admin_base_url, ) except Exception as exc: self.localSaveFailed.emit(str(exc) or "无法写入本地数据库") return self.localSaved.emit( saved.client_id, saved.client_name, self._admin_base_url, ) if self._cancelled: return if self._gateway is None: self.registrationFailed.emit( self._gateway_error or "Admin Gateway 尚未配置" ) return try: receipt = self._gateway.register_client( ClientInfo(saved.client_id, saved.client_name), self._capabilities, ) except AdminGatewayError as exc: self.registrationFailed.emit(str(exc)) except Exception as exc: self.registrationFailed.emit(str(exc) or "Admin 登记失败") else: self.registrationSucceeded.emit(receipt.registered_at) finally: self.completed.emit() class AndroidDeviceSearchWorker(QObject): """在后台搜索设备，也可先恢复一台已保存设备。""" succeeded = pyqtSignal(object) failed = pyqtSignal(str) completed = pyqtSignal() def __init__( self, service: AndroidDeviceService, restore_serial: str = "", ): super().__init__() self._service = service self._restore_serial = restore_serial self._cancelled = False def cancel(self) -> None: """停止后续属性查询；正在执行的命令等待自身超时结束。""" self._cancelled = True @pyqtSlot() def run(self) -> None: try: try: restore_warning = "" if self._restore_serial: try: devices = self._service.restore_saved_device( self._restore_serial, lambda: self._cancelled, ) except AndroidDeviceSearchError as exc: restore_warning = str(exc) devices = self._service.search( lambda: self._cancelled ) else: devices = self._service.search(lambda: self._cancelled) except AndroidDeviceSearchError as exc: if not self._cancelled: self.failed.emit(str(exc)) except Exception as exc: if not self._cancelled: self.failed.emit(str(exc) or "无法搜索 Android 设备") else: if not self._cancelled: self.succeeded.emit( AndroidDeviceSearchResult(devices, restore_warning) ) finally: self.completed.emit() class PddPackageCheckWorker(QObject): """在后台检查一台 Android 设备是否安装 PDD。""" succeeded = pyqtSignal(str, bool) failed = pyqtSignal(str, str) completed = pyqtSignal(str) def __init__(self, service: AndroidDeviceService, serial: str): super().__init__() self._service = service self._serial = serial self._cancelled = False def cancel(self) -> None: """ADB 命令无法中断；完成后不再发送业务结果。""" self._cancelled = True @pyqtSlot() def run(self) -> None: try: try: installed = self._service.is_package_installed( self._serial, PDD_PACKAGE_NAME, ) except AndroidDeviceSearchError as exc: if not self._cancelled: self.failed.emit(self._serial, str(exc)) except Exception as exc: if not self._cancelled: self.failed.emit( self._serial, str(exc) or "无法检测 PDD 应用", ) else: if not self._cancelled: self.succeeded.emit(self._serial, installed) finally: self.completed.emit(self._serial) class AndroidWifiConversionWorker(QObject): """在后台引导一台 USB 设备切换到 Wi-Fi ADB。""" progressChanged = pyqtSignal(str) succeeded = pyqtSignal(object) failed = pyqtSignal(str) completed = pyqtSignal() def __init__(self, service: AndroidDeviceService, usb_serial: str): super().__init__() self._service = service self._usb_serial = usb_serial self._cancelled = False def cancel(self) -> None: """停止轮询和后续命令；正在执行的 ADB 命令等待自身超时。""" self._cancelled = True @pyqtSlot() def run(self) -> None: try: try: result = self._service.convert_usb_to_wifi( self._usb_serial, lambda: self._cancelled, self.progressChanged.emit, ) except AndroidDeviceConversionCancelled: return except AndroidDeviceSearchError as exc: if not self._cancelled: self.failed.emit(str(exc)) except Exception as exc: if not self._cancelled: self.failed.emit(str(exc) or "无法将 USB 设备转为 Wi-Fi") else: if not self._cancelled: self.succeeded.emit(result) finally: self.completed.emit() class AndroidDeviceSettingWorker(QObject): """在后台保存或删除当前使用的 Android 设备号。""" succeeded = pyqtSignal(str, str) failed = pyqtSignal(str, str) completed = pyqtSignal() def __init__( self, service: SelectedAndroidDeviceService, action: str, serial: str = "", ): super().__init__() self._service = service self._action = action self._serial = serial self._cancelled = False def cancel(self) -> None: """写入无法中断；完成后不再向已关闭页面返回结果。""" self._cancelled = True @pyqtSlot() def run(self) -> None: try: try: if self._action == "save": serial = self._service.save(self._serial) elif self._action == "delete": self._service.delete() serial = "" else: raise ValueError("未知的 Android 设备设置操作") except Exception as exc: if not self._cancelled: self.failed.emit( self._action, str(exc) or "无法写入本地数据库", ) else: if not self._cancelled: self.succeeded.emit(self._action, serial) finally: self.completed.emit() class SettingsPageEventBinder(QObject): """绑定设备管理控件，并向应用层发出稳定事件。""" searchRequested = pyqtSignal() convertWifiRequested = pyqtSignal(str) currentDeviceSaveRequested = pyqtSignal(str, str, str) saveRequested = pyqtSignal(str, str) deleteRequested = pyqtSignal(str) androidDeviceConfigurationChanged = pyqtSignal(str) adminBaseUrlChanged = pyqtSignal(str) def __init__( self, page, settings_repository: Optional[SettingsRepository] = None, admin_gateway: Optional[ClientRegistrationGateway] = None, android_device_service: Optional[AndroidDeviceService] = None, update_service=None, update_credential_store=None, live_purchase_adapter_ready: bool = False, ): super().__init__(page) self._page = page self._busy = False self._current_device_busy = False self._closing = False self._thread: Optional[QThread] = None self._worker: Optional[CurrentClientSaveWorker] = None self._search_busy = False self._search_restore_serial = "" self._search_is_startup_restore = False self._search_thread: Optional[QThread] = None self._search_worker: Optional[AndroidDeviceSearchWorker] = None self._pdd_check_busy = False self._pdd_check_serial = "" self._pending_pdd_check_serial = "" self._pending_android_save_serial = "" self._pdd_check_result_serial = "" self._pdd_is_installed = False self._pdd_check_thread: Optional[QThread] = None self._pdd_check_worker: Optional[PddPackageCheckWorker] = None self._wifi_conversion_busy = False self._wifi_conversion_thread: Optional[QThread] = None self._wifi_conversion_worker: Optional[ AndroidWifiConversionWorker ] = None self._android_setting_busy = False self._android_setting_thread: Optional[QThread] = None self._android_setting_worker: Optional[AndroidDeviceSettingWorker] = None self._saved_android_serial = "" self._refresh_registration_after_android_setting = False self._live_purchase_adapter_ready = bool( live_purchase_adapter_ready ) self._adb_unavailable_message = "" if android_device_service is None: try: validate_bundled_adb() except BundledAdbError as exc: self._adb_unavailable_message = str(exc) self._android_device_service = ( android_device_service or AndroidDeviceService() ) repository = settings_repository or SettingsRepository() self._settings_repository = repository self.updateEventBinder = UpdateUiEventBinder( page, repository, service=update_service, credential_store=update_credential_store, parent=self, ) self._client_service = CurrentClientService(repository) self._selected_android_device_service = SelectedAndroidDeviceService( repository ) self._admin_gateway = admin_gateway self._owns_admin_gateway = admin_gateway is None self._pending_admin_gateway = None self._gateway_error = "" if self._admin_gateway is None: base_url = load_admin_base_url(repository) timeout_value = repository.get("admin.request_timeout_seconds", 3.0) try: timeout_seconds = float(timeout_value) self._admin_gateway = HttpAdminGateway( base_url if isinstance(base_url, str) else "", timeout_seconds=timeout_seconds, ) except (TypeError, ValueError) as exc: self._gateway_error = str(exc) page.currentDeviceSaveButton.clicked.connect( self._request_save_current_device ) self.currentDeviceSaveRequested.connect( self._start_save_current_device ) page.searchButton.clicked.connect(self._request_search) self.searchRequested.connect(self._start_search) page.convertWifiButton.clicked.connect(self._request_convert_wifi) self.convertWifiRequested.connect(self._start_convert_wifi) page.saveButton.clicked.connect(self._request_save) self.saveRequested.connect(self._start_save_android_device) page.deleteButton.clicked.connect(self._request_delete) self.deleteRequested.connect(self._start_delete_android_device) page.deviceTableModel.checkedDeviceChanged.connect( self._on_checked_device_changed ) page.destroyed.connect(self.shutdown) application = QCoreApplication.instance() if application is not None: application.aboutToQuit.connect(self.shutdown) self._load_current_client() self._load_selected_android_device() if self._adb_unavailable_message: self._page.deviceStatusLabel.setText( self._adb_unavailable_message ) self._sync_button_state() if self._saved_android_serial and not self._adb_unavailable_message: QTimer.singleShot(0, self._request_restore_saved_android_device) @pyqtSlot() def _request_save_current_device(self) -> None: if ( self._busy or self._current_device_busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return device_id = self._page.deviceIdInput.text().strip() device_name = self._page.deviceNameInput.text().strip() admin_base_url = self._page.adminBaseUrlInput.text().strip() self._page.deviceNameInput.setText(device_name) self.currentDeviceSaveRequested.emit( device_id, device_name, admin_base_url, ) @pyqtSlot(str, str, str) def _start_save_current_device( self, _displayed_device_id: str, device_name: str, admin_base_url: str, ) -> None: if ( self._closing or self._current_device_busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return try: timeout_value = self._settings_repository.get( "admin.request_timeout_seconds", 3.0 ) timeout_seconds = float(timeout_value) validated_gateway = HttpAdminGateway( admin_base_url, timeout_seconds=timeout_seconds, ) normalized_base_url = admin_base_url.strip().rstrip("/") device = self._selected_android_device() purchase_mode = ( "live" if device is not None and self._live_purchase_adapter_ready else "dry_run" ) supported_types = ( (TaskType.COLLECT, TaskType.PURCHASE) if device is not None and self._live_purchase_adapter_ready else (TaskType.COLLECT,) ) capabilities = ClaimCapabilities( device=device, supported_types=supported_types, purchase_mode=purchase_mode, ) except (TypeError, ValueError) as exc: self._page.set_current_device_status(f"保存失败：{exc}") self._page.adminBaseUrlInput.setFocus() return pending_gateway = ( validated_gateway if self._owns_admin_gateway else self._admin_gateway ) self._pending_admin_gateway = pending_gateway self._page.set_admin_base_url(normalized_base_url) self._current_device_busy = True self._sync_button_state() self._page.set_current_device_status("正在保存本地设备信息…") thread = QThread(self) worker = CurrentClientSaveWorker( self._client_service, pending_gateway, device_name, capabilities, normalized_base_url, "", ) worker.moveToThread(thread) thread.started.connect(worker.run) worker.localSaved.connect(self._on_local_saved) worker.localSaveFailed.connect(self._on_local_save_failed) worker.registrationSucceeded.connect(self._on_registration_succeeded) worker.registrationFailed.connect(self._on_registration_failed) worker.completed.connect(thread.quit) worker.completed.connect(worker.deleteLater) thread.finished.connect(self._on_save_thread_finished) thread.finished.connect(thread.deleteLater) self._thread = thread self._worker = worker thread.start() @pyqtSlot() def _request_search(self) -> None: if ( self._busy or self._current_device_busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return self.searchRequested.emit() @pyqtSlot() def _start_search(self) -> None: restore_serial = ( self._saved_android_serial if ":" in self._saved_android_serial else "" ) self._start_search_worker(restore_serial) @pyqtSlot() def _request_restore_saved_android_device(self) -> None: if not self._saved_android_serial: return self._start_search_worker( self._saved_android_serial, is_startup_restore=True, ) def _start_search_worker( self, restore_serial: str = "", is_startup_restore: bool = False, ) -> None: if ( self._closing or self._busy or self._current_device_busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return self._search_busy = True self._search_restore_serial = restore_serial self._search_is_startup_restore = is_startup_restore self._sync_button_state() if is_startup_restore: status = f"正在恢复已保存设备：{restore_serial}…" elif restore_serial: status = f"正在重新连接已保存 Wi-Fi 设备：{restore_serial}…" else: status = "正在搜索 Android 设备…" self._page.deviceStatusLabel.setText(status) thread = QThread(self) worker = AndroidDeviceSearchWorker( self._android_device_service, restore_serial, ) worker.moveToThread(thread) thread.started.connect(worker.run) worker.succeeded.connect(self._on_search_succeeded) worker.failed.connect(self._on_search_failed) worker.completed.connect(thread.quit) worker.completed.connect(worker.deleteLater) thread.finished.connect(self._on_search_thread_finished) thread.finished.connect(thread.deleteLater) self._search_thread = thread self._search_worker = worker thread.start() @pyqtSlot(str) def _on_checked_device_changed(self, serial: str) -> None: """勾选变化后刷新按钮，并为最新设备排队检测 PDD。""" self._sync_button_state() if self._closing: return if self._pending_android_save_serial != serial: self._pending_android_save_serial = "" self._pdd_check_result_serial = "" self._pdd_is_installed = False if not serial: self._pending_pdd_check_serial = "" self._page.set_pdd_app_status("未检测") return self._queue_pdd_package_check(serial) def _queue_pdd_package_check(self, serial: str) -> None: """立即检测或只保留最后一次待检测的设备号。""" if self._closing or not serial: return if self._pdd_check_busy: if serial != self._pdd_check_serial: self._pending_pdd_check_serial = serial self._page.set_pdd_app_status("等待检测…") return if ( self._busy or self._current_device_busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): self._pending_pdd_check_serial = serial self._page.set_pdd_app_status("等待检测…") return self._start_pdd_package_check(serial) def _start_pdd_package_check(self, serial: str) -> None: """启动单次后台包检测；同一时间最多运行一个。""" if self._closing or self._pdd_check_busy: return self._pending_pdd_check_serial = "" self._pdd_check_busy = True self._pdd_check_serial = serial self._page.set_pdd_app_status("正在检测…") self._sync_button_state() thread = QThread(self) worker = PddPackageCheckWorker( self._android_device_service, serial, ) worker.moveToThread(thread) thread.started.connect(worker.run) worker.succeeded.connect(self._on_pdd_package_check_succeeded) worker.failed.connect(self._on_pdd_package_check_failed) worker.completed.connect(thread.quit) worker.completed.connect(worker.deleteLater) thread.finished.connect(self._on_pdd_package_check_finished) thread.finished.connect(thread.deleteLater) self._pdd_check_thread = thread self._pdd_check_worker = worker thread.start() @pyqtSlot(str, bool) def _on_pdd_package_check_succeeded( self, serial: str, installed: bool, ) -> None: if self._closing: return if serial != self._page.deviceTableModel.checked_serial: return self._pdd_check_result_serial = serial self._pdd_is_installed = installed if installed: self._page.set_pdd_app_status( f"{PDD_PACKAGE_NAME}（已安装）" ) return self._page.set_pdd_app_status("未安装，请先在手机安装拼多多") if self._pending_android_save_serial == serial: self._pending_android_save_serial = "" self._page.deviceStatusLabel.setText( "保存失败：所选设备未安装 PDD，请安装后重试" ) @pyqtSlot(str, str) def _on_pdd_package_check_failed( self, serial: str, message: str, ) -> None: if self._closing: return if serial != self._page.deviceTableModel.checked_serial: return self._pdd_check_result_serial = serial self._pdd_is_installed = False self._page.set_pdd_app_status(f"检测失败：{message}") if self._pending_android_save_serial == serial: self._pending_android_save_serial = "" self._page.deviceStatusLabel.setText( f"保存失败：无法确认 PDD 安装状态；{message}；原配置未更改" ) @pyqtSlot() def _on_pdd_package_check_finished(self) -> None: finished_serial = self._pdd_check_serial self._pdd_check_worker = None self._pdd_check_thread = None self._pdd_check_busy = False self._pdd_check_serial = "" if self._closing: return current_serial = self._page.deviceTableModel.checked_serial pending_serial = self._pending_pdd_check_serial if pending_serial and pending_serial == current_serial: self._queue_pdd_package_check(pending_serial) return self._pending_pdd_check_serial = "" if ( self._pending_android_save_serial == finished_serial and self._pdd_check_result_serial == finished_serial and self._pdd_is_installed and current_serial == finished_serial ): self._pending_android_save_serial = "" self.saveRequested.emit("", finished_serial) return self._sync_button_state() @pyqtSlot() def _request_convert_wifi(self) -> None: if ( self._busy or self._current_device_busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return serial = self._page.deviceTableModel.checked_serial device = self._page.deviceTableModel.device_for_serial(serial) if device is None or device.status != "device": self._page.deviceStatusLabel.setText( "转换失败：请先勾选一台已连接的 USB 设备" ) self._page.deviceTable.setFocus() return if device.connection_type != "USB": self._page.deviceStatusLabel.setText( "转换失败：当前设备已经是 Wi-Fi 连接" ) return self.convertWifiRequested.emit(serial) @pyqtSlot(str) def _start_convert_wifi(self, usb_serial: str) -> None: if ( self._closing or self._busy or self._current_device_busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return self._wifi_conversion_busy = True self._sync_button_state() self._page.deviceStatusLabel.setText("正在准备 USB 转 Wi-Fi…") thread = QThread(self) worker = AndroidWifiConversionWorker( self._android_device_service, usb_serial, ) worker.moveToThread(thread) thread.started.connect(worker.run) worker.progressChanged.connect(self._on_wifi_conversion_progress) worker.succeeded.connect(self._on_wifi_conversion_succeeded) worker.failed.connect(self._on_wifi_conversion_failed) worker.completed.connect(thread.quit) worker.completed.connect(worker.deleteLater) thread.finished.connect(self._on_wifi_conversion_finished) thread.finished.connect(thread.deleteLater) self._wifi_conversion_thread = thread self._wifi_conversion_worker = worker thread.start() @pyqtSlot() def _request_save(self) -> None: if ( self._busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return serial = self._page.deviceTableModel.checked_serial if not serial: self._page.deviceStatusLabel.setText("保存失败：请先勾选一台已连接设备") self._page.deviceTable.setFocus() return self._pending_android_save_serial = serial self._page.deviceStatusLabel.setText( "正在确认所选设备是否安装 PDD…" ) self._queue_pdd_package_check(serial) @pyqtSlot(str, str) def _start_save_android_device( self, _unused_device_name: str, serial: str ) -> None: self._start_android_device_setting("save", serial) @pyqtSlot() def _request_delete(self) -> None: if ( self._busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return serial = self._saved_android_serial if not serial: self._page.deviceStatusLabel.setText("删除失败：当前没有已保存设备") return self.deleteRequested.emit(serial) @pyqtSlot(str) def _start_delete_android_device(self, _serial: str) -> None: self._start_android_device_setting("delete") def _start_android_device_setting( self, action: str, serial: str = "" ) -> None: if ( self._closing or self._busy or self._search_busy or self._wifi_conversion_busy or self._android_setting_busy ): return self._android_setting_busy = True self._sync_button_state() message = ( "正在保存当前使用设备…" if action == "save" else "正在删除已保存设备配置…" ) self._page.deviceStatusLabel.setText(message) thread = QThread(self) worker = AndroidDeviceSettingWorker( self._selected_android_device_service, action, serial, ) worker.moveToThread(thread) thread.started.connect(worker.run) worker.succeeded.connect(self._on_android_device_setting_succeeded) worker.failed.connect(self._on_android_device_setting_failed) worker.completed.connect(thread.quit) worker.completed.connect(worker.deleteLater) thread.finished.connect(self._on_android_device_setting_finished) thread.finished.connect(thread.deleteLater) self._android_setting_thread = thread self._android_setting_worker = worker thread.start() @pyqtSlot() def _sync_button_state(self, *_args) -> None: serial = self._page.deviceTableModel.checked_serial selected_device = self._page.deviceTableModel.device_for_serial(serial) self._page.currentDeviceSaveButton.setEnabled( not self._busy and not self._current_device_busy and not self._search_busy and not self._wifi_conversion_busy and not self._android_setting_busy ) device_commands_enabled = ( not self._adb_unavailable_message and not self._busy and not self._search_busy and not self._wifi_conversion_busy and not self._android_setting_busy ) self._page.searchButton.setEnabled( device_commands_enabled and not self._current_device_busy ) self._page.saveButton.setEnabled( device_commands_enabled and not self._pdd_check_busy and bool(serial) ) self._page.convertWifiButton.setEnabled( device_commands_enabled and not self._current_device_busy and selected_device is not None and selected_device.status == "device" and selected_device.connection_type == "USB" ) self._page.deleteButton.setEnabled( device_commands_enabled and bool(self._saved_android_serial) ) def set_busy(self, busy: bool, message: str = "") -> None: """切换界面忙碌状态，防止用户重复提交设备命令。""" self._busy = busy self._sync_button_state() if message: self._page.deviceStatusLabel.setText(message) def _load_current_client(self) -> None: """页面创建时恢复本地 Client 信息。""" try: displayed_base_url = load_admin_base_url( self._settings_repository ) saved = self._client_service.load() except Exception as exc: self._page.set_current_device_status( f"读取本地设备信息失败：{str(exc) or '数据库不可用'}" ) return self._page.set_admin_base_url(displayed_base_url) self._page.set_client_info(saved.client_id, saved.client_name) if saved.client_id: self._page.set_current_device_status("本地设备信息已加载") def _load_selected_android_device(self) -> None: """页面创建时恢复自动化应使用的 Android 设备号。""" try: serial = self._selected_android_device_service.load() except Exception as exc: self._page.deviceStatusLabel.setText( f"读取已保存 Android 设备失败：{str(exc) or '数据库不可用'}" ) return self._saved_android_serial = serial if serial: self._page.deviceStatusLabel.setText( f"当前使用设备：{serial}（等待搜索确认连接）" ) def _selected_android_device(self) -> Optional[AndroidDeviceInfo]: serial = self._selected_android_device_service.load().strip() return AndroidDeviceInfo(serial) if serial else None @pyqtSlot(object) def _on_search_succeeded(self, result: AndroidDeviceSearchResult) -> None: if self._closing: return rows = [ AndroidDeviceRow( serial=device.serial, connection_type=device.connection_type, model=device.model, android_version=device.android_version, status=device.status, ) for device in result.devices ] self._page.set_android_devices(rows) saved_device = self._page.deviceTableModel.device_for_serial( self._saved_android_serial ) if saved_device is not None and saved_device.status == "device": self._page.deviceTableModel.set_checked_serial( self._saved_android_serial ) if result.restore_warning: action = ( "自动恢复未完成" if self._search_is_startup_restore else "搜索完成" ) found_text = ( f"找到 {len(rows)} 台 Android 设备" if rows else "未找到其他 Android 设备" ) self._page.deviceStatusLabel.setText( f"{action}：{found_text}；已保存设备 " f"{self._saved_android_serial} 恢复失败：" f"{result.restore_warning}；配置已保留" ) elif saved_device is not None and saved_device.status == "device": action = ( "恢复完成" if self._search_is_startup_restore else "搜索完成" ) self._page.deviceStatusLabel.setText( f"{action}：找到 {len(rows)} 台 Android 设备；" "已自动选择当前使用设备" ) elif saved_device is not None and saved_device.status == "unauthorized": self._page.deviceStatusLabel.setText( "已重新连接 Wi-Fi 设备，但尚未授权：" f"{self._saved_android_serial}；请在手机上允许调试后重试" ) elif saved_device is not None: self._page.deviceStatusLabel.setText( "已保存设备当前不可用：" f"{self._saved_android_serial}（{saved_device.status}）；" "配置已保留" ) elif self._saved_android_serial: self._page.deviceStatusLabel.setText( "已保存设备当前未连接：" f"{self._saved_android_serial}；配置已保留" ) elif rows: self._page.deviceStatusLabel.setText( f"搜索完成：找到 {len(rows)} 台 Android 设备" ) else: self._page.deviceStatusLabel.setText( "未找到 Android 设备，请检查 USB 调试或无线连接后重试" ) selected_serial = self._page.deviceTableModel.checked_serial if selected_serial: self._queue_pdd_package_check(selected_serial) else: self._page.set_pdd_app_status("未检测") @pyqtSlot(str) def _on_search_failed(self, message: str) -> None: if self._closing: return if self._search_is_startup_restore: self._page.deviceStatusLabel.setText( f"自动恢复失败：{message}；已保存配置未更改，" "可点击搜索重试" ) elif self._search_restore_serial: self._page.deviceStatusLabel.setText( f"搜索失败：无法重新连接已保存 Wi-Fi 设备；{message}；" "已保存配置未更改，可重试" ) else: self._page.deviceStatusLabel.setText( f"搜索失败：{message}；设备列表和已保存配置未更改" ) @pyqtSlot() def _on_search_thread_finished(self) -> None: self._search_worker = None self._search_thread = None self._search_busy = False self._search_restore_serial = "" self._search_is_startup_restore = False if not self._closing: self._sync_button_state() pending_serial = self._pending_pdd_check_serial if pending_serial: self._queue_pdd_package_check(pending_serial) @pyqtSlot(str) def _on_wifi_conversion_progress(self, message: str) -> None: if not self._closing: self._page.deviceStatusLabel.setText(message) @pyqtSlot(object) def _on_wifi_conversion_succeeded(self, result) -> None: if self._closing: return rows = [ AndroidDeviceRow( serial=device.serial, connection_type=device.connection_type, model=device.model, android_version=device.android_version, status=device.status, ) for device in result.devices ] self._page.set_android_devices(rows) self._page.deviceTableModel.set_checked_serial(result.wifi_serial) self._page.deviceStatusLabel.setText( f"Wi-Fi 设备 {result.wifi_serial} 已连接并勾选；" "请确认后点击保存，再拔掉 USB 数据线" ) @pyqtSlot(str) def _on_wifi_conversion_failed(self, message: str) -> None: if self._closing: return self._page.deviceStatusLabel.setText( f"转换失败：{message}；设备列表和已保存配置未更改，可重试" ) @pyqtSlot() def _on_wifi_conversion_finished(self) -> None: self._wifi_conversion_worker = None self._wifi_conversion_thread = None self._wifi_conversion_busy = False if not self._closing: self._sync_button_state() pending_serial = self._pending_pdd_check_serial if pending_serial: self._queue_pdd_package_check(pending_serial) @pyqtSlot(str, str) def _on_android_device_setting_succeeded( self, action: str, serial: str ) -> None: if self._closing: return if action == "save": self._saved_android_serial = serial self._page.deviceStatusLabel.setText( f"当前使用设备：{serial}（已保存）" ) self.androidDeviceConfigurationChanged.emit(serial) else: self._saved_android_serial = "" self._page.deviceTableModel.set_checked_serial("") self._page.deviceStatusLabel.setText( "当前使用设备：未选择（本地配置已删除）" ) self.androidDeviceConfigurationChanged.emit("") displayed_client_id = self._page.deviceIdInput.text().strip() self._refresh_registration_after_android_setting = bool( displayed_client_id and displayed_client_id != DEVICE_ID_PLACEHOLDER ) @pyqtSlot(str, str) def _on_android_device_setting_failed( self, action: str, message: str ) -> None: if self._closing: return action_text = "保存" if action == "save" else "删除" self._page.deviceStatusLabel.setText( f"{action_text}失败：{message}；原设备配置未更改，可重试" ) self._refresh_registration_after_android_setting = False @pyqtSlot() def _on_android_device_setting_finished(self) -> None: self._android_setting_worker = None self._android_setting_thread = None self._android_setting_busy = False if not self._closing: self._sync_button_state() if self._refresh_registration_after_android_setting: self._refresh_registration_after_android_setting = False QTimer.singleShot(0, self._request_save_current_device) @pyqtSlot(str, str, str) def _on_local_saved( self, client_id: str, client_name: str, admin_base_url: str, ) -> None: if self._closing: return self._page.set_client_info(client_id, client_name) self._page.set_admin_base_url(admin_base_url) self._admin_gateway = self._pending_admin_gateway self._gateway_error = "" self.adminBaseUrlChanged.emit(admin_base_url) self._page.set_current_device_status( "本地已保存，正在登记到 Admin…" ) @pyqtSlot(str) def _on_local_save_failed(self, message: str) -> None: if self._closing: return self._page.set_current_device_status(f"本地保存失败：{message}") self._pending_admin_gateway = None @pyqtSlot(str) def _on_registration_succeeded(self, _registered_at: str) -> None: if self._closing: return self._page.set_current_device_status("本地已保存，已登记到 Admin") @pyqtSlot(str) def _on_registration_failed(self, message: str) -> None: if self._closing: return self._page.set_current_device_status( f"本地已保存，Admin 登记失败：{message}；可再次点击保存重试" ) @pyqtSlot() def _on_save_thread_finished(self) -> None: self._worker = None self._thread = None self._current_device_busy = False self._pending_admin_gateway = None if not self._closing: self._sync_button_state() @pyqtSlot() def shutdown(self) -> None: """窗口关闭时忽略迟到结果，并等待短请求安全结束。""" if self._closing: return self._closing = True self.updateEventBinder.shutdown() worker = self._worker thread = self._thread if worker is not None: worker.cancel() for signal, slot in ( (worker.localSaved, self._on_local_saved), (worker.localSaveFailed, self._on_local_save_failed), (worker.registrationSucceeded, self._on_registration_succeeded), (worker.registrationFailed, self._on_registration_failed), ): try: signal.disconnect(slot) except TypeError: pass if thread is not None and thread.isRunning(): thread.quit() thread.wait(4000) search_worker = self._search_worker search_thread = self._search_thread if search_worker is not None: try: search_worker.cancel() signal_slots = ( (search_worker.succeeded, self._on_search_succeeded), (search_worker.failed, self._on_search_failed), ) except RuntimeError: # Worker 已调用 deleteLater，但 finished 清理槽还在消息队列中。 signal_slots = () for signal, slot in signal_slots: try: signal.disconnect(slot) except (TypeError, RuntimeError): pass if search_thread is not None and search_thread.isRunning(): search_thread.quit() search_thread.wait(6000) pdd_worker = self._pdd_check_worker pdd_thread = self._pdd_check_thread if pdd_worker is not None: try: pdd_worker.cancel() signal_slots = ( ( pdd_worker.succeeded, self._on_pdd_package_check_succeeded, ), ( pdd_worker.failed, self._on_pdd_package_check_failed, ), ) except RuntimeError: # Worker 已调用 deleteLater，但 thread.finished 的清理槽 # 还在主线程队列中时，Python 引用可能暂时仍存在。 signal_slots = () for signal, slot in signal_slots: try: signal.disconnect(slot) except (TypeError, RuntimeError): pass if pdd_thread is not None and pdd_thread.isRunning(): pdd_thread.quit() pdd_thread.wait(6000) conversion_worker = self._wifi_conversion_worker conversion_thread = self._wifi_conversion_thread if conversion_worker is not None: try: conversion_worker.cancel() signal_slots = ( ( conversion_worker.progressChanged, self._on_wifi_conversion_progress, ), ( conversion_worker.succeeded, self._on_wifi_conversion_succeeded, ), ( conversion_worker.failed, self._on_wifi_conversion_failed, ), ) except RuntimeError: signal_slots = () for signal, slot in signal_slots: try: signal.disconnect(slot) except (TypeError, RuntimeError): pass if conversion_thread is not None and conversion_thread.isRunning(): conversion_thread.quit() conversion_thread.wait(6000) setting_worker = self._android_setting_worker setting_thread = self._android_setting_thread if setting_worker is not None: try: setting_worker.cancel() signal_slots = ( ( setting_worker.succeeded, self._on_android_device_setting_succeeded, ), ( setting_worker.failed, self._on_android_device_setting_failed, ), ) except RuntimeError: signal_slots = () for signal, slot in signal_slots: try: signal.disconnect(slot) except (TypeError, RuntimeError): pass if setting_thread is not None and setting_thread.isRunning(): setting_thread.quit() setting_thread.wait(4000)