"""Application composition root for the doctor workstation.""" from __future__ import annotations import logging import os import sys import time from collections.abc import Mapping, Sequence from contextlib import suppress from typing import Any from PySide6.QtCore import QLibraryInfo, QLocale, QObject, Qt, QTimer, QTranslator from PySide6.QtGui import QGuiApplication, QIcon from PySide6.QtWidgets import ( QApplication, QDialog, QFrame, QHBoxLayout, QLabel, QPushButton, QVBoxLayout, QWidget, ) from doctor_workstation.config import AppConfig from doctor_workstation.core import Session from doctor_workstation.core.errors import AuthenticationExpiredError from doctor_workstation.logging_setup import configure_logging from doctor_workstation.resources import app_icon_path, video_dist_path from doctor_workstation.services import ( DemoDoctorRepository, RemoteDoctorRepository, TokenStore, build_repository, ) from doctor_workstation.ui import LoginWindow, ShellWindow, apply_theme from doctor_workstation.ui.dialogs.app_update import AppUpdateSession from doctor_workstation.ui.widgets import ( first_value, friendly_error, gender_text, get_value, has_permission, run_async, set_authentication_expired_handler, show_toast, ) from doctor_workstation.video import BackendMode, launch_video_call from doctor_workstation.video.window import WEBENGINE_AVAILABLE LOGGER = logging.getLogger(__name__) def _video_case_text(value: Any, *, limit: int = 2000) -> str: """Render a bounded, JSON-safe clinical value for the trusted call rail.""" if value in (None, "", [], {}): return "" if isinstance(value, Mapping): parts = [ f"{key}:{_video_case_text(item, limit=limit)}" for key, item in value.items() if item not in (None, "", [], {}) ] return ";".join(part for part in parts if not part.endswith(":"))[:limit] if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)): return "、".join( part for item in value if (part := _video_case_text(item, limit=limit)) )[:limit] return str(value).strip()[:limit] def _video_identity(value: Any) -> str: if value in (None, "") or isinstance(value, bool): return "" text = str(value).strip() if not text: return "" with suppress(ValueError, TypeError): return str(int(text)) return text def _video_identity_matches(expected: Any, actual: Any) -> bool: normalized_actual = _video_identity(actual) return not normalized_actual or normalized_actual == _video_identity(expected) def _build_video_patient_case( detail: Any, fallback_record: Any, *, diagnosis_id: Any, patient_id: Any, patient_name: str, ) -> dict[str, str]: """Reduce the readonly diagnosis aggregate to the fields needed in-call.""" if isinstance(detail, Mapping) and not get_value(detail, "diagnosis", None): nested = get_value(detail, "data", None) if isinstance(nested, Mapping): detail = nested diagnosis = get_value(detail, "diagnosis", None) if not diagnosis and isinstance(detail, Mapping): diagnosis = detail diagnosis = diagnosis or {} patient = get_value(detail, "patient", None) or {} appointment = get_value(detail, "appointment", None) or {} detail_diagnosis_id = first_value(diagnosis, "id", "diagnosis_id", default=None) detail_patient_id = first_value( diagnosis, "source_patient_id", default=first_value( patient, "source_patient_id", default=None, ), ) if not _video_identity_matches( diagnosis_id, detail_diagnosis_id, ) or not _video_identity_matches(patient_id, detail_patient_id): detail = diagnosis = patient = appointment = {} fallback_diagnosis_id = first_value( fallback_record, "diagnosis_id", "id", default=None, ) fallback_patient_id = first_value( fallback_record, "source_patient_id", "patient_id", default=None, ) if not _video_identity_matches( diagnosis_id, fallback_diagnosis_id, ) or not _video_identity_matches(patient_id, fallback_patient_id): fallback_record = {} sources = (diagnosis, patient, appointment, fallback_record) def pick(*keys: str, limit: int = 2000) -> str: for source in sources: value = first_value(source, *keys, default=None) text = _video_case_text(value, limit=limit) if text: return text return "" raw_gender = next( ( first_value(source, "gender_desc", "gender", default=None) for source in sources if first_value(source, "gender_desc", "gender", default=None) not in (None, "") ), None, ) return { "diagnosisId": _video_case_text(diagnosis_id, limit=80), "name": pick("patient_name", "name", limit=120) or _video_case_text(patient_name, limit=120) or "患者", "gender": "" if raw_gender in (None, "") else gender_text(raw_gender), "age": pick("age", limit=20), "height": pick("height", limit=20), "weight": pick("weight", limit=20), "diagnosisDate": pick("diagnosis_date", "diagnosis_date_text", limit=80), "appointmentDate": pick( "appointment_date", "latest_appointment_date", limit=80, ), "clinicalDiagnosis": pick( "clinical_diagnosis", "diagnosis_name", "disease_name", ), "chiefComplaint": pick("chief_complaint", "complaint"), "presentIllness": pick("present_illness", "present_illness_history", "symptoms"), "pastHistory": pick("past_history_text", "past_history_desc", "past_history"), "allergyHistory": pick( "allergy_history_text", "allergy_history_desc", "allergy_history", ), "personalHistory": pick( "personal_history_text", "personal_history_desc", "personal_history", ), "familyHistory": pick( "family_history_text", "family_history_desc", "family_history", ), "currentMedication": pick( "current_medications", "current_medicine", "current_medication", ), "tongue": pick("tongue", "tongue_coating"), "pulse": pick("pulse", "pulse_condition"), "prescriptionOpinion": pick("prescription_opinion", "prescription_advice"), "remark": pick("remark"), } class _ChineseQtTranslator(QTranslator): """Guarantee Chinese labels for common Qt standard buttons. Qt's packaged ``qtbase_zh_CN`` catalog remains the primary source for framework text. This small fallback also keeps release builds localized when a packager omits the optional ``.qm`` files. """ _BUTTON_TEXT = { "OK": "确定", "Open": "打开", "Save": "保存", "Save All": "全部保存", "Cancel": "取消", "Close": "关闭", "Yes": "是", "Yes to All": "全部确认", "No": "否", "No to All": "全部否定", "Abort": "中止", "Retry": "重试", "Ignore": "忽略", "Discard": "放弃", "Help": "帮助", "Apply": "应用", "Reset": "重置", "Restore Defaults": "恢复默认设置", "Don't Save": "不保存", } def translate( self, context: str, source_text: str, disambiguation: str | None = None, n: int = -1, ) -> str | None: del context, disambiguation, n # Returning an empty string tells Qt that an unknown source string has # a valid, deliberately empty translation. That also erased internal # values such as QPageSize's "A4", producing zero-sized PDF pages. # ``None`` delegates unknown text to Qt's installed catalog/source. return self._BUTTON_TEXT.get(source_text.replace("&", "")) def _install_chinese_translations(application: QApplication) -> None: """Install Simplified Chinese Qt catalogs once for the whole process.""" if getattr(application, "_doctor_workstation_chinese_translators", None): return QLocale.setDefault(QLocale("zh_CN")) translators: list[QTranslator] = [] translations_path = QLibraryInfo.path(QLibraryInfo.LibraryPath.TranslationsPath) for catalog in ("qt_zh_CN", "qtbase_zh_CN"): translator = QTranslator(application) if translator.load(catalog, translations_path): application.installTranslator(translator) translators.append(translator) fallback = _ChineseQtTranslator(application) application.installTranslator(fallback) translators.append(fallback) application._doctor_workstation_chinese_translators = translators # type: ignore[attr-defined] class _UnconfiguredRepository: """Login boundary used until an administrator supplies a backend URL.""" def login( self, account: str, password: str, *, remember_account: bool = False, ) -> Session: del account, password, remember_account raise ValueError("请先展开“服务器设置”,填写管理员提供的 HTTPS 接口地址。") def get_current_user(self) -> None: return None class DemoVideoDialog(QDialog): """Non-network video-room preview used only by the explicit demo mode.""" def __init__(self, patient_name: str, parent: QWidget | None = None) -> None: super().__init__(parent) self._seconds = 0 self.setWindowTitle("视频面诊 · 演示模式") self.setMinimumSize(760, 520) self.resize(980, 660) self.setModal(False) self.setStyleSheet( "QDialog{background:#F7F9FE;color:#111F46;}" "QLabel{color:#111F46;}" "QFrame#RemoteStage{background:#0E1421;border:1px solid #29334F;border-radius:16px;}" "QFrame#RemoteStage QLabel{color:#F7F9FE;}" "QFrame#LocalStage{background:#151D31;border:1px solid #3F4E75;border-radius:12px;}" "QPushButton{min-width:96px;min-height:40px;padding:0 16px;border-radius:9px;" "background:#FFFFFF;color:#3F4E75;border:1px solid #E6EAF5;font-weight:600;}" "QPushButton:hover{color:#4451E2;background:#F0F2FF;border-color:#5761F4;}" "QPushButton:checked{color:#FFFFFF;background:#5761F4;border-color:#5761F4;}" "QPushButton#Hangup{color:#FFFFFF;background:#C23D4E;border-color:#C23D4E;}" "QPushButton#Hangup:hover{background:#D94857;border-color:#D94857;}" ) root = QVBoxLayout(self) root.setContentsMargins(22, 18, 22, 22) root.setSpacing(14) header = QHBoxLayout() title = QLabel(f"与 {patient_name or '患者'} 的视频面诊") title.setStyleSheet("font-size:18px;font-weight:700;") header.addWidget(title) header.addStretch(1) demo = QLabel("● 演示模式 · 未连接腾讯云") demo.setStyleSheet("color:#707584;font-size:12px;") header.addWidget(demo) self.duration_label = QLabel("00:00") self.duration_label.setStyleSheet("font-weight:700;") header.addWidget(self.duration_label) root.addLayout(header) stage = QFrame() stage.setObjectName("RemoteStage") stage_layout = QVBoxLayout(stage) stage_layout.setContentsMargins(22, 22, 22, 22) stage_layout.addStretch(1) avatar = QLabel((patient_name or "患")[:1]) avatar.setAlignment(Qt.AlignmentFlag.AlignCenter) avatar.setFixedSize(104, 104) avatar.setStyleSheet( "background:#F0F2FF;color:#5761F4;border-radius:52px;font-size:42px;font-weight:700;" ) stage_layout.addWidget(avatar, 0, Qt.AlignmentFlag.AlignHCenter) waiting = QLabel("等待患者接听…") waiting.setAlignment(Qt.AlignmentFlag.AlignCenter) waiting.setStyleSheet("font-size:17px;font-weight:600;") stage_layout.addWidget(waiting) hint = QLabel("生产模式将通过后端短时 UserSig 初始化腾讯 TUICallKit") hint.setAlignment(Qt.AlignmentFlag.AlignCenter) hint.setStyleSheet("color:#A4ADC3;font-size:12px;") stage_layout.addWidget(hint) stage_layout.addStretch(1) local = QFrame(stage) local.setObjectName("LocalStage") local.setGeometry(24, 24, 178, 112) local_layout = QVBoxLayout(local) local_label = QLabel("医生画面") local_label.setAlignment(Qt.AlignmentFlag.AlignCenter) local_label.setStyleSheet("color:#D9E0F2;font-weight:600;") local_layout.addWidget(local_label) root.addWidget(stage, 1) controls = QHBoxLayout() controls.addStretch(1) self.mic_button = QPushButton("麦克风 开") self.mic_button.setCheckable(True) self.mic_button.toggled.connect( lambda muted: self.mic_button.setText("麦克风 关" if muted else "麦克风 开") ) controls.addWidget(self.mic_button) self.camera_button = QPushButton("摄像头 开") self.camera_button.setCheckable(True) self.camera_button.toggled.connect( lambda off: self.camera_button.setText("摄像头 关" if off else "摄像头 开") ) controls.addWidget(self.camera_button) hangup = QPushButton("结束面诊") hangup.setObjectName("Hangup") hangup.clicked.connect(self.close) controls.addWidget(hangup) controls.addStretch(1) root.addLayout(controls) self._timer = QTimer(self) self._timer.timeout.connect(self._tick) self._timer.start(1000) def _tick(self) -> None: self._seconds += 1 minutes, seconds = divmod(self._seconds, 60) self.duration_label.setText(f"{minutes:02d}:{seconds:02d}") class ApplicationController(QObject): """Own windows, repositories and the authenticated application lifecycle.""" def __init__(self, application: QApplication, config: AppConfig) -> None: super().__init__() self.application = application self.config = config self.debug_mode = bool(getattr(config, "debug_mode", False)) self.token_store = TokenStore(config.config_dir / "credentials.json") self.demo_repository = DemoDoctorRepository() if self.debug_mode else None self.remote_repository: RemoteDoctorRepository | None = None self.login_window: LoginWindow | None = None self.shell_window: ShellWindow | None = None self.current_repository: Any = None self.current_demo_mode = self.debug_mode and config.demo_mode self.video_calls: dict[str, Any] = {} self.video_pending: dict[str, object] = {} self._pending_im_request: tuple[str, object] | None = None self.demo_video_dialogs: dict[str, DemoVideoDialog] = {} self._video_preview_state: dict[str, Any] | None = None self._video_preview_generation = 0 self._restore_generation = 0 self._restore_in_progress = False self._restore_worker: Any = None self._shutting_down = False self._authentication_expiry_in_progress = False self._rebuild_remote_repository() self.app_updater = AppUpdateSession(self) set_authentication_expired_handler(self._on_authentication_expired) application.aboutToQuit.connect(self.shutdown) def start(self) -> None: """Show login immediately, then validate a production token off-thread.""" self._show_login() self._begin_session_restore() self.app_updater.schedule() def _base_repository(self) -> Any: return self.remote_repository or _UnconfiguredRepository() def _show_login(self) -> None: if self.login_window is None: self.login_window = LoginWindow( self._base_repository(), self.config, self.demo_repository, credential_store=self.token_store, ) self.login_window.login_succeeded.connect(self._on_login_succeeded) self.login_window.config_changed.connect(self._on_config_changed) self.login_window.demo_mode_changed.connect(self._on_demo_mode_changed) self._apply_window_icon(self.login_window) else: self.login_window.repository = self._base_repository() self.login_window.config = self.config if not self.login_window.demo_check.isChecked(): self.login_window.active_repository = self._base_repository() self.login_window.restore_remembered_credentials() self.login_window.show() self.login_window.raise_() self.login_window.activateWindow() def _on_config_changed(self, payload: Any) -> None: previous_connection = ( self.config.api_base_url, self.config.request_timeout, self.config.verify_ssl, ) if isinstance(payload, AppConfig): updated = payload elif isinstance(payload, dict): aliases = { "base_url": "api_base_url", "read_timeout": "request_timeout", } changes = {aliases.get(key, key): value for key, value in payload.items()} allowed = { "api_base_url", "demo_mode", "video_mode", "video_web_url", "verify_ssl", "request_timeout", "log_level", "remembered_account", } updated = self.config.with_updates( **{key: value for key, value in changes.items() if key in allowed} ) else: return self.config = updated with suppress(OSError): self.config.save_preferences() next_connection = ( self.config.api_base_url, self.config.request_timeout, self.config.verify_ssl, ) if next_connection != previous_connection: self._cancel_session_restore() self._rebuild_remote_repository() if self.login_window is not None: self.login_window.repository = self._base_repository() if not self.login_window.demo_check.isChecked(): self.login_window.active_repository = self._base_repository() self.app_updater.schedule() if self.login_window is not None: self.login_window.config = self.config def _on_demo_mode_changed(self, enabled: bool) -> None: allowed = self.debug_mode and enabled self.current_demo_mode = allowed if allowed: self._cancel_session_restore() def _rebuild_remote_repository(self) -> None: old = self.remote_repository self.remote_repository = None if self.config.api_base_url: repository = build_repository( demo=False, base_url=self.config.api_base_url, token_store=self.token_store, timeout=self.config.request_timeout, verify=self.config.verify_ssl, ) if isinstance(repository, RemoteDoctorRepository): self.remote_repository = repository if old is not None and old is not self.current_repository: with suppress(Exception): old.client.close() def _begin_session_restore(self) -> None: """Validate a scoped persisted token without racing manual login.""" repository = self.remote_repository if ( self._shutting_down or self.config.demo_mode or repository is None or self.current_repository is not None ): return self._restore_generation += 1 generation = self._restore_generation self._restore_in_progress = True if self.login_window is not None: self.login_window.set_session_restore_pending(True) self._restore_worker = run_async( repository.restore_session, on_success=lambda session: self._on_restore_success( session, repository, generation, ), on_error=lambda error: self._on_restore_error( error, repository, generation, ), on_finished=lambda: self._on_restore_finished(repository, generation), ) def _restore_is_current( self, repository: RemoteDoctorRepository, generation: int, ) -> bool: """Return whether a restore callback still owns the login surface.""" return ( not self._shutting_down and self._restore_in_progress and generation == self._restore_generation and repository is self.remote_repository ) def _finish_session_restore( self, repository: RemoteDoctorRepository, generation: int, ) -> bool: """Release login controls only for the currently active restore.""" if not self._restore_is_current(repository, generation): return False self._restore_in_progress = False self._restore_worker = None if self.login_window is not None: self.login_window.set_session_restore_pending(False) return True def _on_restore_success( self, session: object, repository: RemoteDoctorRepository, generation: int, ) -> None: """Enter the shell only for a current, fully validated session.""" if not self._finish_session_restore(repository, generation): return if session is None: return if not isinstance(session, Session) or not session.authenticated: with suppress(Exception): repository.logout() self._login_guard_error("已保存的登录状态无效,请重新登录。") return self._on_login_succeeded( { "session": session, "user": session.user, "repository": repository, "demo_mode": False, "restored_session": True, } ) def _on_restore_error( self, error: Exception, repository: RemoteDoctorRepository, generation: int, ) -> None: """Return control to login after a current restore attempt fails.""" if not self._finish_session_restore(repository, generation): return if isinstance(error, AuthenticationExpiredError): message = "登录状态已失效,请重新登录。" else: message = f"自动恢复登录失败:{friendly_error(error)}" self._login_guard_error(message) def _on_restore_finished( self, repository: RemoteDoctorRepository, generation: int, ) -> None: """Release controls when a worker finishes without a result callback.""" self._finish_session_restore(repository, generation) def _cancel_session_restore(self) -> None: """Invalidate late callbacks and re-enable manual login controls.""" self._restore_generation += 1 if not self._restore_in_progress: return self._restore_in_progress = False self._restore_worker = None if self.login_window is not None: self.login_window.set_session_restore_pending(False) def _on_login_succeeded(self, payload: dict[str, Any]) -> None: self._cancel_session_restore() session = payload.get("session") repository = payload.get("repository") if not isinstance(session, Session) or repository is None: self._login_guard_error("登录响应不完整,请重试。") return if session.password_change_required: with suppress(Exception): repository.logout() self._login_guard_error("该账号需要先修改初始密码,请在管理后台完成后重新登录。") return if session.work_wechat_binding_required: with suppress(Exception): repository.logout() self._login_guard_error("该账号需要先绑定企业微信,请在管理后台完成绑定后重新登录。") return demo_mode = self.debug_mode and bool(payload.get("demo_mode")) payload["demo_mode"] = demo_mode if not demo_mode and not session.menu: with suppress(Exception): repository.logout() self._login_guard_error("当前账号没有可用医生端菜单,请联系管理员授权。") return self.current_repository = repository self._authentication_expiry_in_progress = False self.current_demo_mode = demo_mode self.shell_window = ShellWindow(repository, payload, session.permissions) self.shell_window.logout_requested.connect(self._logout) self.shell_window.video_requested.connect(self._request_video) self.shell_window.update_check_requested.connect( lambda: self.app_updater.check(interactive=True) ) self._apply_window_icon(self.shell_window) if self.login_window is not None: self.login_window.hide() self.shell_window.show() self.shell_window.raise_() self.shell_window.activateWindow() self.app_updater.schedule(delay_ms=400) def _login_guard_error(self, message: str) -> None: if self.login_window is not None: self.login_window.error_banner.show_message(message, "warning") self.login_window.show() def _on_authentication_expired(self, error: AuthenticationExpiredError) -> bool: """Consume an active-shell expiry and atomically return to login.""" if self.shell_window is None or self.current_repository is None: return False if self._authentication_expiry_in_progress: return True self._authentication_expiry_in_progress = True LOGGER.info( "authenticated session expired", extra={"api_code": error.code, "request_id": error.request_id}, ) self._logout(message="登录状态已失效,请重新登录。") return True def _logout(self, *, message: str = "") -> None: """Clear authenticated resources and return to the login window.""" self._restore_video_preview(activate=False) calls = tuple(self.video_calls.values()) for call in calls: with suppress(Exception): call.close() self._wait_for_video_lifecycle(calls, timeout=1.25) self.video_calls.clear() self.video_pending.clear() self._pending_im_request = None for dialog in self.demo_video_dialogs.values(): dialog.close() self.demo_video_dialogs.clear() if self.current_repository is not None: with suppress(Exception): self.current_repository.logout() self.current_repository = None if self.shell_window is not None: self.shell_window.close() self.shell_window.deleteLater() self.shell_window = None self._show_login() if message and self.login_window is not None: self.login_window.error_banner.show_message(message, "warning") def _request_video(self, payload: dict[str, Any]) -> None: parent = self.shell_window if parent is None or self.current_repository is None: return patient_id = payload.get("patient_id") diagnosis_id = payload.get("diagnosis_id") appointment_id = int(payload.get("appointment_id") or 0) patient_name = str(payload.get("patient_name") or "患者") open_im = str(payload.get("mode") or "video").lower() == "im" fallback_record = payload.get("record") if patient_id in (None, "") or diagnosis_id in (None, ""): show_toast(parent, "患者或诊单信息不完整,无法发起视频。", "danger", 4200) return call_key = f"{diagnosis_id}:{appointment_id}" if open_im and self._pending_im_request is not None: pending_key, pending_marker = self._pending_im_request if pending_key != call_key: # Retire a previous selection before any early return, including # when the selected IM window is already open. if self.video_pending.get(pending_key) is pending_marker: self.video_pending.pop(pending_key, None) self._pending_im_request = None existing_call = self.video_calls.get(call_key) if open_im and existing_call is not None and getattr(existing_call, "open_im", False): qt_window = getattr(existing_call, "qt_window", None) if qt_window is not None: qt_window.show() qt_window.raise_() qt_window.activateWindow() show_toast(parent, "该患者的 IM 会话已经打开。", "info", 3200) return if ( call_key in self.video_pending or existing_call is not None or call_key in self.demo_video_dialogs ): show_toast(parent, "该问诊的视频正在准备或通话中。", "info", 3600) return closed_previous_im = False if open_im: for key, call in tuple(self.video_calls.items()): if key == call_key or not getattr(call, "open_im", False): continue closed_previous_im = True self.video_calls.pop(key, None) with suppress(Exception): call.close() if self.current_demo_mode: dialog = DemoVideoDialog(patient_name, parent) dialog.finished.connect( lambda _result, key=call_key, item=dialog: self._forget_demo_dialog( key, item, ) ) self.demo_video_dialogs[call_key] = dialog dialog.show() return show_toast( parent, "正在打开患者 IM 会话…" if open_im else "正在获取安全通话凭证…", "info", ) repository = self.current_repository marker = object() self.video_pending[call_key] = marker if open_im: self._pending_im_request = (call_key, marker) def get_video_context() -> tuple[Any, dict[str, str]]: ticket = repository.get_call_ticket( patient_id=int(patient_id), diagnosis_id=int(diagnosis_id), appointment_id=appointment_id, ) if appointment_id and int(ticket.raw.get("appointment_id") or 0) != appointment_id: raise ValueError("通话凭证与本次挂号不匹配,请重新打开聊天窗口。") detail: Any = {} detail_loader = getattr(repository, "patient_detail", None) if callable(detail_loader): try: detail = detail_loader(int(diagnosis_id)) except Exception as error: LOGGER.warning( "patient detail could not be loaded for video call", extra={ "diagnosis_id": diagnosis_id, "error_type": type(error).__name__, }, ) patient_case = _build_video_patient_case( detail, fallback_record, diagnosis_id=diagnosis_id, patient_id=patient_id, patient_name=patient_name, ) return ticket, patient_case def request_ticket() -> None: if self.video_pending.get(call_key) is not marker: return run_async( get_video_context, on_success=lambda context: self._launch_video( context[0], diagnosis_id=diagnosis_id, patient_id=patient_id, repository=repository, call_key=call_key, marker=marker, open_im=open_im, patient_name=patient_name, patient_case=context[1], ), on_error=lambda error: self._video_ticket_error( call_key, marker, parent, error, ), ) # Tencent IM may take a brief moment to release the previous browser # connection. The admin version also has only one ChatDialog instance. if closed_previous_im: QTimer.singleShot(400, request_ticket) else: request_ticket() def _video_ticket_error( self, call_key: str, marker: object, parent: QWidget, error: Exception, ) -> None: if self.video_pending.get(call_key) is not marker: return self.video_pending.pop(call_key, None) if self._pending_im_request == (call_key, marker): self._pending_im_request = None if self.shell_window is parent: show_toast( parent, f"视频准备失败:{friendly_error(error)}", "danger", 5200, ) def _launch_video( self, ticket: Any, *, diagnosis_id: Any, patient_id: Any, repository: Any, call_key: str, marker: object, open_im: bool = False, patient_name: str = "患者", patient_case: Mapping[str, Any] | None = None, ) -> None: if self.video_pending.get(call_key) is not marker: return self.video_pending.pop(call_key, None) if self._pending_im_request == (call_key, marker): self._pending_im_request = None if ( self.shell_window is None or self.current_repository is not repository or call_key in self.video_calls ): return try: mode = BackendMode.parse(self.config.video_mode) if mode is BackendMode.BROWSER: raise ValueError("当前后端未提供一次性通话交接票据,浏览器视频模式已安全停用。") if not WEBENGINE_AVAILABLE: raise ValueError("当前安装缺少 QtWebEngine,无法打开受信任的视频窗口。") call = launch_video_call( ticket, repository=repository, diagnosis_id=diagnosis_id, patient_id=patient_id, backend_mode=mode, local_dist=video_dist_path(), remote_url=self.config.video_web_url or None, logger=logging.getLogger("doctor_workstation.video"), open_im=open_im, patient_name=patient_name, patient_case=patient_case, can_ai_assistant=has_permission( getattr(self.shell_window, "permissions", None), "tcm.diagnosis/aiAssistant", default=False, ), on_open_diagnosis=lambda current_id=diagnosis_id, current_key=call_key: ( self._open_video_diagnosis(current_id, call_key=current_key) ), ) except Exception as error: LOGGER.exception("video call could not be launched") show_toast( self.shell_window, f"视频启动失败:{friendly_error(error)}", "danger", 5600, ) return self.video_calls[call_key] = call qt_window = getattr(call, "qt_window", None) if qt_window is not None: qt_window.destroyed.connect( lambda _obj=None, key=call_key, expected=call: self._release_video_call( key, expected, ) ) def _open_video_diagnosis(self, diagnosis_id: Any, *, call_key: str) -> None: """Open the diagnosis while keeping its live video visible as a preview.""" shell = self.shell_window if shell is None or self.current_repository is None: return dialog = shell.open_diagnosis_by_id(diagnosis_id, modeless=True) if dialog is None: return call = self.video_calls.get(call_key) video_window = getattr(call, "qt_window", None) if video_window is not None: self._show_video_preview(video_window, dialog) def _show_video_preview(self, video_window: Any, dialog: QDialog) -> None: """Pin a compact call window above the modeless diagnosis drawer.""" current = self._video_preview_state if current is not None and current.get("window") is not video_window: self._restore_video_preview(activate=False) self._video_preview_generation += 1 generation = self._video_preview_generation if current is None or current.get("window") is not video_window: try: state = { "window": video_window, "geometry": video_window.geometry(), "minimum_size": video_window.minimumSize(), "maximized": video_window.isMaximized(), "full_screen": video_window.isFullScreen(), "stays_on_top": bool( video_window.windowFlags() & Qt.WindowType.WindowStaysOnTopHint ), } screen = video_window.screen() or QGuiApplication.primaryScreen() available = screen.availableGeometry() preview_width = min(540, max(460, round(available.width() * 0.29))) preview_height = min(380, max(320, round(preview_width * 0.66))) margin = 18 if callable(getattr(video_window, "setProperty", None)): video_window.setProperty("doctorSkipOpenGeometry", True) video_window.showNormal() video_window.setMinimumSize(440, 300) video_window.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True) video_window.resize(preview_width, preview_height) video_window.move( available.x() + available.width() - preview_width - margin, available.y() + margin, ) video_window.show() self._video_preview_state = state except RuntimeError: self._video_preview_state = None return dialog.finished.connect( lambda _result, expected=generation: self._restore_video_preview(expected) ) try: set_close_handler = getattr(video_window, "set_compact_close_handler", None) if callable(set_close_handler): set_close_handler(lambda expected=generation: self._restore_video_preview(expected)) video_window.raise_() dialog.raise_() dialog.activateWindow() except RuntimeError: self._restore_video_preview(generation, activate=False) def _restore_video_preview( self, generation: int | None = None, *, activate: bool = True, ) -> None: if generation is not None and generation != self._video_preview_generation: return state = self._video_preview_state if state is None: return self._video_preview_state = None self._video_preview_generation += 1 window = state.get("window") try: set_close_handler = getattr(window, "set_compact_close_handler", None) if callable(set_close_handler): set_close_handler(None) restore_screenshot = getattr(window, "restore_screenshot_preview", None) if callable(restore_screenshot): restore_screenshot() window.setWindowFlag( Qt.WindowType.WindowStaysOnTopHint, bool(state.get("stays_on_top")), ) window.setMinimumSize(state["minimum_size"]) window.setGeometry(state["geometry"]) if state.get("full_screen"): window.showFullScreen() elif state.get("maximized"): window.showMaximized() else: window.showNormal() window.raise_() if activate: window.activateWindow() if callable(getattr(window, "setProperty", None)): window.setProperty("doctorSkipOpenGeometry", False) except (AttributeError, RuntimeError): return def _release_video_call(self, call_key: str, call: Any) -> None: preview = self._video_preview_state if preview is not None and preview.get("window") is getattr(call, "qt_window", None): self._video_preview_state = None self._video_preview_generation += 1 if self.video_calls.get(call_key) is call: self.video_calls.pop(call_key, None) def _forget_demo_dialog(self, call_key: str, dialog: DemoVideoDialog) -> None: if self.demo_video_dialogs.get(call_key) is dialog: self.demo_video_dialogs.pop(call_key, None) dialog.deleteLater() @staticmethod def _wait_for_video_lifecycle(calls: tuple[Any, ...], *, timeout: float) -> bool: """Give queued endCall writes one short shared deadline after media closes.""" deadline = time.monotonic() + max(0.0, timeout) complete = True for call in calls: remaining = deadline - time.monotonic() if remaining <= 0: complete = False break wait = getattr(call, "wait_for_lifecycle", None) if callable(wait) and not wait(remaining): complete = False if not complete: LOGGER.warning("video lifecycle cleanup exceeded its bounded deadline") return complete @staticmethod def _apply_window_icon(window: QWidget) -> None: icon_file = app_icon_path() if icon_file.exists(): window.setWindowIcon(QIcon(str(icon_file))) def request_quit(self) -> None: """Queue a normal application exit so owned resources are released.""" if self._shutting_down: return QTimer.singleShot(0, self.application.quit) def shutdown(self) -> None: """Invalidate asynchronous restoration and release owned resources.""" if self._shutting_down: return self._shutting_down = True self._cancel_session_restore() self.app_updater.shutdown() set_authentication_expired_handler(None) self._restore_video_preview(activate=False) calls = tuple(self.video_calls.values()) for call in calls: with suppress(Exception): call.close() self._wait_for_video_lifecycle(calls, timeout=1.25) if self.remote_repository is not None: with suppress(Exception): self.remote_repository.client.close() def _prefer_native_tls_backend() -> None: """Keep Qt's HTTPS stack off OpenSSL. PySide6 on Windows ships no OpenSSL DLLs of its own, so Qt's OpenSSL TLS backend resolves to CPython's ``libcrypto-3-x64.dll`` and ends up sharing one OpenSSL instance with the httpx stack. Concurrent use from both stacks has crashed the process inside libcrypto (access violation at a stable offset) while pages downloaded images through ``QNetworkAccessManager``. Route Qt network requests through the native Schannel backend instead, which uses the Windows certificate store and never touches OpenSSL. """ with suppress(Exception): from PySide6.QtNetwork import QSslSocket backends = QSslSocket.availableBackends() if "schannel" in backends and "openssl" in backends: QSslSocket.setActiveBackend("schannel") _CRASH_LOG_HANDLE: Any = None def _install_crash_handler(config: AppConfig) -> None: """Write per-thread Python tracebacks of native crashes into the log dir. Debug launchers already pass ``-X faulthandler`` and dump to stderr; keep that behavior and only redirect into ``crash.log`` for packaged or plain runs where stderr is lost. """ global _CRASH_LOG_HANDLE try: import faulthandler if faulthandler.is_enabled(): return path = config.log_dir / "crash.log" handle = path.open("a", encoding="utf-8", buffering=1) handle.write(f"\n=== process started {time.strftime('%Y-%m-%d %H:%M:%S')} ===\n") faulthandler.enable(file=handle, all_threads=True) _CRASH_LOG_HANDLE = handle except Exception: LOGGER.exception("crash handler could not be installed") def _create_application(argv: list[str]) -> QApplication: with suppress(AttributeError): QGuiApplication.setHighDpiScaleFactorRoundingPolicy( Qt.HighDpiScaleFactorRoundingPolicy.PassThrough ) with suppress(AttributeError): QApplication.setAttribute(Qt.ApplicationAttribute.AA_DontCreateNativeWidgetSiblings, True) application = QApplication(argv) _prefer_native_tls_backend() _install_chinese_translations(application) application.setApplicationName("甄养堂医生工作站") application.setApplicationDisplayName("甄养堂医生工作站") application.setOrganizationName("ZhenYangTang") application.setOrganizationDomain("zhenyangtang.com") application.setQuitOnLastWindowClosed(True) icon_file = app_icon_path() if icon_file.exists(): application.setWindowIcon(QIcon(str(icon_file))) apply_theme(application) return application def main(argv: list[str] | None = None) -> int: """Start the GUI application and return its process exit code.""" config = AppConfig.load() configure_logging(config.log_dir, config.log_level) _install_crash_handler(config) LOGGER.info("doctor workstation starting", extra={"demo_mode": config.demo_mode}) raw_argv = list(sys.argv if argv is None else argv) smoke_test = "--smoke-test" in raw_argv application = _create_application( [argument for argument in raw_argv if argument != "--smoke-test"] ) controller = ApplicationController(application, config) controller.start() if smoke_test or os.getenv("DOCTOR_SMOKE_TEST") == "1": QTimer.singleShot(1200, application.quit) return application.exec() __all__ = ["ApplicationController", "DemoVideoDialog", "main"]