Files
zyt/app/src/doctor_workstation/video/window.py
T

1755 lines
73 KiB
Python
Executable File

"""Hardened QtWebEngine host for the video companion.
Browser launch is intentionally disabled until the backend provides a
single-use handoff ticket. PySide6 remains optional at import time, while an
actual call requires an isolated QtWebEngine profile and an active QApplication.
"""
from __future__ import annotations
import base64
import binascii
import json
import logging
import math
import os
import re
import sqlite3
import sys
from collections.abc import Callable, Mapping
from concurrent.futures import Future
from contextlib import suppress
from dataclasses import dataclass
from pathlib import Path
from typing import Any
from urllib.parse import parse_qsl, urlsplit
from ..services.local_audio_queue import (
LocalAudioQueueStore,
LocalAudioUploadManager,
get_local_audio_upload_manager,
)
from .im_ai import ImAiController
from .launcher import (
VideoCallRequest,
VideoTicketError,
require_supported_backend,
)
from .lifecycle import OrderedCallLifecycle, normalize_transcript_segment
from .live_ai import LiveAiController
from .screenshot import ScreenshotPreviewSize, capture_view_region
from .security import TrustedDocumentError, TrustedDocumentPolicy
try: # Optional by design: core-only builds must still import this module.
from PySide6.QtCore import QObject, Qt, QTimer, QUrl, Signal, Slot
from PySide6.QtWebChannel import QWebChannel
from PySide6.QtWebEngineCore import (
QWebEnginePage,
QWebEngineProfile,
QWebEngineSettings,
)
from PySide6.QtWebEngineWidgets import QWebEngineView
from PySide6.QtWidgets import QApplication, QMainWindow
except (ImportError, OSError) as _qt_import_error: # pragma: no cover - no Qt runtime.
QObject = QTimer = Qt = QUrl = Signal = Slot = None # type: ignore[assignment]
QWebChannel = QWebEnginePage = QWebEngineProfile = None # type: ignore[assignment]
QWebEngineSettings = QWebEngineView = None # type: ignore[assignment]
QApplication = QMainWindow = None # type: ignore[assignment]
_WEBENGINE_IMPORT_ERROR: Exception | None = _qt_import_error
else: # pragma: no cover - requires a GUI runtime.
_WEBENGINE_IMPORT_ERROR = None
WEBENGINE_AVAILABLE = _WEBENGINE_IMPORT_ERROR is None
_LOGGER = logging.getLogger(__name__)
_SENSITIVE_QUERY_KEYS = {"usersig", "sdksecret", "sdksecretkey", "secretkey"}
class VideoWindowError(RuntimeError):
"""Raised when the trusted embedded companion cannot be opened."""
@dataclass(frozen=True, slots=True)
class CompanionLocation:
url: str
is_local: bool
@dataclass(slots=True)
class _LocalAudioCapture:
record_id: int
session_id: str
mime_type: str
path: Path
handle: Any
lifecycle: OrderedCallLifecycle
next_sequence: int = 0
bytes_written: int = 0
def _validate_remote_url(value: str) -> str:
parsed = urlsplit(value)
if parsed.scheme.lower() != "https" or not parsed.hostname:
raise VideoWindowError("remote video companion URL must use HTTPS")
if parsed.username or parsed.password:
raise VideoWindowError("remote video companion URL must not contain credentials")
url_parameter_keys = {
"".join(character for character in key.lower() if character.isalnum())
for key, _ in (*parse_qsl(parsed.query), *parse_qsl(parsed.fragment))
}
if url_parameter_keys & _SENSITIVE_QUERY_KEYS:
raise VideoWindowError("remote video companion URL must not contain RTC credentials")
return value
def _candidate_index(local_dist: str | Path) -> Path:
candidate = Path(local_dist).expanduser().resolve()
return candidate if candidate.name.lower() == "index.html" else candidate / "index.html"
def _default_local_indexes() -> tuple[Path, ...]:
candidates: list[Path] = []
bundle_root = getattr(sys, "_MEIPASS", None)
if bundle_root:
candidates.append(Path(bundle_root) / "video_companion_dist" / "index.html")
project_root = Path(__file__).resolve().parents[3]
candidates.append(project_root / "video_companion" / "dist" / "index.html")
return tuple(candidates)
def resolve_companion_location(
*,
local_dist: str | Path | None = None,
remote_url: str | None = None,
) -> CompanionLocation:
"""Resolve the trusted document used inside QtWebEngine."""
indexes = (
(_candidate_index(local_dist),) if local_dist is not None else _default_local_indexes()
)
for index in indexes:
if index.is_file():
return CompanionLocation(index.as_uri(), is_local=True)
if remote_url:
return CompanionLocation(_validate_remote_url(remote_url), is_local=False)
raise VideoWindowError(
"video companion is unavailable: build video_companion/dist or configure an HTTPS URL"
)
def webengine_unavailable_reason() -> str | None:
"""Return a non-sensitive diagnostic reason without importing Qt again."""
if _WEBENGINE_IMPORT_ERROR is None:
return None
return f"{type(_WEBENGINE_IMPORT_ERROR).__name__}: QtWebEngine is not installed"
if WEBENGINE_AVAILABLE: # pragma: no cover - GUI behavior needs an integration test.
class _RestrictedWebEnginePage(QWebEnginePage): # type: ignore[misc, valid-type]
def __init__(
self,
profile: Any,
policy: TrustedDocumentPolicy,
logger: logging.Logger,
parent: Any,
) -> None:
super().__init__(profile, parent)
self._policy = policy
self._logger = logger
self._shutting_down = False
def begin_shutdown(self) -> None:
self._shutting_down = True
def acceptNavigationRequest(
self,
url: Any,
navigation_type: Any,
is_main_frame: bool,
) -> bool:
del navigation_type
if not is_main_frame:
return True
rendered = url.toString()
if self._shutting_down and rendered == "about:blank":
return True
if self._policy.allows_main_document(rendered):
return True
self._logger.warning(
"blocked video companion main-document navigation",
extra={
"target_scheme": url.scheme(),
"target_host": url.host(),
},
)
return False
def createWindow(self, window_type: Any) -> Any:
del window_type
self._logger.warning("blocked video companion popup window")
return None
class _QtVideoBridge(QObject): # type: ignore[misc, valid-type]
def __init__(
self,
callback: Callable[[Mapping[str, Any]], None],
capture_screenshot: Callable[[Mapping[str, Any]], str],
) -> None:
super().__init__()
self._callback = callback
self._capture_screenshot = capture_screenshot
@Slot(str, result=str) # type: ignore[misc]
def captureScreenshot(self, payload: str) -> str: # noqa: N802 - Qt bridge API
"""Return a local preview only; persistence still needs saveScreenshot."""
try:
if not isinstance(payload, str) or len(payload) > 2048:
raise ValueError("截屏区域无效,请重试。")
region = json.loads(payload)
if not isinstance(region, Mapping):
raise ValueError("截屏区域无效,请重试。")
result = {"dataUrl": self._capture_screenshot(region)}
except (ValueError, TypeError, RuntimeError):
result = {"error": "无法截取当前视频画面,请稍后重试。"}
return json.dumps(result, ensure_ascii=False)
@Slot(str) # type: ignore[misc]
def notify(self, payload: str) -> None:
if not isinstance(payload, str) or len(payload) > 16_384:
return
try:
message = json.loads(payload)
except (TypeError, ValueError):
return
if isinstance(message, Mapping) and message.get("source") == "doctor-call":
self._callback(message)
@Slot(str) # type: ignore[misc]
def saveScreenshot(self, data_url: str) -> None: # noqa: N802 - Qt bridge API
"""Forward one bounded JPEG data URL to the trusted desktop host."""
if not isinstance(data_url, str) or len(data_url) > 14 * 1024 * 1024:
self._callback(
{
"source": "doctor-call",
"event": "screenshot-invalid",
"message": "截屏图片过大,无法保存。",
}
)
return
self._callback(
{
"source": "doctor-call",
"event": "screenshot",
"dataUrl": data_url,
}
)
@Slot(str, str) # type: ignore[misc]
def startLocalAudioRecording( # noqa: N802 - Qt bridge API
self, session_id: str, mime_type: str
) -> None:
self._callback(
{
"source": "doctor-call",
"event": "local-audio-start",
"sessionId": session_id,
"mimeType": mime_type,
}
)
@Slot(str, int, str) # type: ignore[misc]
def appendLocalAudioChunk( # noqa: N802 - Qt bridge API
self, session_id: str, sequence: int, encoded: str
) -> None:
self._callback(
{
"source": "doctor-call",
"event": "local-audio-chunk",
"sessionId": session_id,
"sequence": sequence,
"data": encoded,
}
)
@Slot(str, int) # type: ignore[misc]
def finishLocalAudioRecording( # noqa: N802 - Qt bridge API
self, session_id: str, total_bytes: int
) -> None:
self._callback(
{
"source": "doctor-call",
"event": "local-audio-finish",
"sessionId": session_id,
"totalBytes": total_bytes,
}
)
@Slot(str) # type: ignore[misc]
def abortLocalAudioRecording(self, session_id: str) -> None: # noqa: N802
self._callback(
{
"source": "doctor-call",
"event": "local-audio-abort",
"sessionId": session_id,
}
)
@Slot(str, str, int, float, str) # type: ignore[misc]
def appendLocalTranscriptionChunk( # noqa: N802
self, session_id: str, role: str, sequence: int, timestamp: float, encoded: str
) -> None:
if len(encoded) > 512_000:
return
self._callback({"source": "doctor-call", "event": "local-transcription-chunk",
"sessionId": session_id, "role": role, "sequence": sequence,
"timestamp": timestamp, "data": encoded})
class _EmbeddedVideoWindow(QMainWindow): # type: ignore[misc, valid-type]
status_changed = Signal(str) # type: ignore[misc]
call_ended = Signal(str) # type: ignore[misc]
call_error = Signal(str) # type: ignore[misc]
_start_completed = Signal(bool) # type: ignore[misc]
_policy_completed = Signal(str, object) # type: ignore[misc]
_room_completed = Signal(str, bool, str) # type: ignore[misc]
_screenshot_completed = Signal(bool, str) # type: ignore[misc]
_transcription_completed = Signal(str, str, str, bool, str, str) # type: ignore[misc]
_local_transcription_event = Signal(object) # type: ignore[misc]
_local_recording_completed = Signal( # type: ignore[misc]
str, str, int, bool, str
)
def __init__(
self,
request: VideoCallRequest,
location: CompanionLocation,
lifecycle: OrderedCallLifecycle,
*,
logger: logging.Logger,
lifecycle_factory: Callable[[], OrderedCallLifecycle],
open_im: bool = False,
patient_name: str = "患者",
patient_case: Mapping[str, Any] | None = None,
on_open_diagnosis: Callable[[], None] | None = None,
can_ai_assistant: bool = False,
repository: Any = None,
) -> None:
super().__init__()
self.request = request
self.location = location
self.lifecycle = lifecycle
self._lifecycle_factory = lifecycle_factory
self._lifecycles = [lifecycle]
self.logger = logger
self.open_im = bool(open_im)
self.patient_name = str(patient_name or "患者").strip() or "患者"
self.patient_case = dict(patient_case or {})
self._on_open_diagnosis = on_open_diagnosis
self._on_compact_close: Callable[[], None] | None = None
try:
self._policy = TrustedDocumentPolicy.from_url(
location.url,
is_local=location.is_local,
)
except TrustedDocumentError as error:
raise VideoWindowError(str(error)) from error
self._injected = False
self._media_active = False
self._closing = False
self._companion_ended = False
self._released = False
self._close_reason = "window-closed"
self._call_cycle_closed = False
self._start_requested = False
self._shutdown_requested = False
self._im_ai = ImAiController(
repository,
diagnosis_id=request.diagnosis_id,
appointment_id=request.appointment_id,
doctor_account=request.user_id,
enabled=can_ai_assistant is True and self.open_im,
)
self._im_ai_timer = QTimer(self)
self._im_ai_timer.setInterval(60)
self._im_ai_timer.timeout.connect(self._flush_im_ai)
if self._im_ai.enabled:
self._im_ai_timer.start()
self._live_ai = LiveAiController(
repository, diagnosis_id=request.diagnosis_id, enabled=can_ai_assistant is True,
)
# The default recognizer is Tencent's existing call transcriber.
# Keep local audio recording independent; no local model is loaded.
self._local_transcription = None
self._asr_session_id = ""
self._asr_ready = False
self._asr_partial = False
self._transcription_final_status = "idle"
self._video_ai_timer = QTimer(self)
self._video_ai_timer.setInterval(100)
self._video_ai_timer.timeout.connect(self._flush_video_ai)
self._video_ai_timer.start()
self._screenshot_preview_size = ScreenshotPreviewSize()
self._local_audio_capture: _LocalAudioCapture | None = None
self._local_audio_store: LocalAudioQueueStore | None = None
self._local_audio_uploads: LocalAudioUploadManager | None = None
self._legacy_grants: list[tuple[Any, Any]] = []
self._permission_grants: list[Any] = []
self._shutdown_timer = QTimer(self)
self._shutdown_timer.setSingleShot(True)
self._shutdown_timer.timeout.connect(self._force_requested_shutdown)
self.setWindowTitle(
f"与 {self.patient_name} IM 问诊" if self.open_im else "视频面诊"
)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
self.resize(1120, 760)
self.setMinimumSize(760, 520)
self._profile = QWebEngineProfile(self)
if not self._profile.isOffTheRecord():
raise VideoWindowError("video WebEngine profile must be off-the-record")
profile_policy = QWebEngineProfile.PersistentCookiesPolicy
cache_type = QWebEngineProfile.HttpCacheType
self._profile.setPersistentCookiesPolicy(profile_policy.NoPersistentCookies)
self._profile.setHttpCacheType(cache_type.MemoryHttpCache)
self._profile.downloadRequested.connect(self._deny_download)
self.web_view = QWebEngineView(self)
self._page = _RestrictedWebEnginePage(
self._profile,
self._policy,
self.logger,
self.web_view,
)
self.web_view.setPage(self._page)
self.setCentralWidget(self.web_view)
self._configure_settings(self._page.settings())
self._bridge = _QtVideoBridge(
self._handle_bridge_message, self._capture_screenshot_preview
)
self._channel = QWebChannel(self._page)
self._channel.registerObject("qtVideoBridge", self._bridge)
self._page.setWebChannel(self._channel)
self._connect_permissions()
self._start_completed.connect(self._on_lifecycle_started)
self._policy_completed.connect(self._on_policy_completed)
self._room_completed.connect(self._on_room_completed)
self._screenshot_completed.connect(self._on_screenshot_completed)
self._transcription_completed.connect(self._on_transcription_completed)
self._local_transcription_event.connect(self._on_local_transcription)
self._local_recording_completed.connect(self._on_local_recording_completed)
self.web_view.loadFinished.connect(self._on_load_finished)
self.web_view.setUrl(QUrl(self.location.url))
def _configure_settings(self, settings: Any) -> None:
attributes = getattr(QWebEngineSettings, "WebAttribute", QWebEngineSettings)
values = (
("LocalContentCanAccessRemoteUrls", self.location.is_local),
("PlaybackRequiresUserGesture", False),
("JavascriptCanOpenWindows", False),
("AllowRunningInsecureContent", False),
)
for name, enabled in values:
attribute = getattr(attributes, name, None)
if attribute is not None:
settings.setAttribute(attribute, enabled)
def _connect_permissions(self) -> None:
if hasattr(self._page, "featurePermissionRequested"):
self._page.featurePermissionRequested.connect(self._grant_legacy_media_permission)
if hasattr(self._page, "permissionRequested"):
self._page.permissionRequested.connect(self._grant_media_permission)
def _permission_context_is_trusted(self, origin: Any) -> bool:
if self._closing or self._released or not self._media_active:
return False
if not self._policy.allows_main_document(self._page.url().toString()):
return False
return self._policy.allows_origin(origin.toString())
def _grant_legacy_media_permission(self, origin: Any, feature: Any) -> None:
features = QWebEnginePage.Feature
allowed = {
features.MediaAudioCapture,
features.MediaVideoCapture,
features.MediaAudioVideoCapture,
}
policies = QWebEnginePage.PermissionPolicy
trusted = self._permission_context_is_trusted(origin) and feature in allowed
policy = (
policies.PermissionGrantedByUser if trusted else policies.PermissionDeniedByUser
)
self._page.setFeaturePermission(origin, feature, policy)
if trusted:
self._legacy_grants.append((origin, feature))
def _grant_media_permission(self, permission: Any) -> None:
permission_type = permission.permissionType()
allowed_names = {
"MediaAudioCapture",
"MediaVideoCapture",
"MediaAudioVideoCapture",
}
trusted = (
permission.isValid()
and permission_type.name in allowed_names
and self._permission_context_is_trusted(permission.origin())
)
if trusted:
permission.grant()
self._permission_grants.append(permission)
else:
permission.deny()
def _deny_download(self, download: Any) -> None:
download.cancel()
def _on_load_finished(self, succeeded: bool) -> None:
if self._closing:
return
if not succeeded:
self.logger.error(
"embedded video companion failed to load",
extra={"video_call": self.request.safe_log_context()},
)
self._request_companion_shutdown("page-load-failed")
return
self._media_active = True
config = {
**self.request.to_web_config(),
"patientName": self.patient_name,
"patientCase": self.patient_case,
"mode": "chat" if self.open_im else "video",
"imAi": self._im_ai.config,
}
config_json = json.dumps(config, ensure_ascii=True, separators=(",", ":"))
script = f"""
(() => {{
if (!window.doctorConsultation
|| typeof window.doctorConsultation.open !== 'function') {{
return false;
}}
void window.doctorConsultation.open({config_json}).catch(() => undefined);
return true;
}})()
"""
self._page.runJavaScript(script, self._after_injection)
def _notify_start_completed(self, future: Future[bool]) -> None:
try:
succeeded = bool(future.result())
except Exception:
succeeded = False
with suppress(RuntimeError):
self._start_completed.emit(succeeded)
def _on_lifecycle_started(self, succeeded: bool) -> None:
if self._closing:
return
if not succeeded:
self._start_requested = False
self._call_cycle_closed = True
self._page.runJavaScript(
"window.doctorConsultation?.hostCallReady?.(false, "
'"通话记录创建失败,请稍后重试。");'
)
return
self._page.runJavaScript(
"window.doctorConsultation?.hostCallReady?.(true, '');"
)
def _after_injection(self, result: Any) -> None:
self._injected = result is not False
if not self._injected:
self._request_companion_shutdown("bridge-api-missing")
return
if not self._im_ai_context_is_trusted():
return
# open() may finish IM login before runJavaScript returns. Only
# acknowledge readiness after the native request gate is open.
session_id = json.dumps(self._im_ai.session_id, ensure_ascii=True)
self._page.runJavaScript(
f"window.doctorConsultation?.imAiReady?.({session_id});"
)
def _handle_bridge_message(self, message: Mapping[str, Any]) -> None:
if self._closing:
return
event = str(message.get("event", ""))
if event.startswith("local-transcription-"):
# An old companion must not start a second recognizer.
return
if event == "video-ai-action":
self._handle_video_assistance_message(message)
return
if event.startswith("transcription-") and not self._local_transcription_context_is_trusted():
return
if event in {"im-ai-request", "im-ai-cancel"}:
self._handle_im_ai_message(message)
return
if event == "screenshot-preview":
visible = message.get("visible")
if isinstance(visible, bool):
self._set_screenshot_preview_visible(visible)
return
if event == "open-diagnosis-request":
if self._on_open_diagnosis is not None:
QTimer.singleShot(0, self._open_diagnosis_safely)
return
if event == "call-start-request":
self._start_call_cycle(call_type=message.get("callType", 2))
return
if event == "call-policy-request":
self._refresh_call_policy(str(message.get("requestId") or ""))
return
if event == "screenshot":
self._save_screenshot(str(message.get("dataUrl") or ""))
return
if event == "screenshot-invalid":
self._on_screenshot_completed(
False,
str(message.get("message") or "截屏图片无效。")[:200],
)
return
if event == "local-audio-start":
self._start_local_audio_recording(
str(message.get("sessionId") or ""),
str(message.get("mimeType") or "audio/webm"),
)
return
if event == "local-audio-chunk":
self._append_local_audio_chunk(
str(message.get("sessionId") or ""),
message.get("sequence"),
str(message.get("data") or ""),
)
return
if event == "local-audio-finish":
self._finish_local_audio_recording(
str(message.get("sessionId") or ""),
message.get("totalBytes"),
)
return
if event == "local-audio-abort":
self._abort_local_audio_recording(str(message.get("sessionId") or ""))
return
if event == "transcription-start-request":
if (self._shutdown_requested or not self._start_requested
or self._call_cycle_closed or not self.lifecycle.call_record_id):
return
self._start_transcription(
str(message.get("sessionId") or ""),
str(message.get("language") or "zh-CN"),
)
return
if event == "transcription-segment":
self._save_transcript_segment(message)
return
if event == "transcription-ready":
session_id = str(message.get("sessionId") or "")
if (not self._shutdown_requested and session_id
and session_id == str(self.lifecycle.transcription_session_id or "")):
self._live_ai.transcription_running(session_id)
return
if event == "transcription-error":
if (str(message.get("sessionId") or "")
== str(self.lifecycle.transcription_session_id or "")
and self.lifecycle.transcription_session_id):
self._asr_partial = True
self._live_ai.transcription_error(
str(message.get("message") or "腾讯云实时转写未完成,请重试。")[:240],
status="failed",
)
return
if event == "transcription-stop":
self._finish_transcription(
str(message.get("sessionId") or ""),
str(message.get("status") or "completed"),
)
return
room_id = message.get("roomId", message.get("room_id"))
if room_id not in (None, ""):
clean_room_id = str(room_id).strip()
future = self.lifecycle.bind_room(clean_room_id)
future.add_done_callback(
lambda completed, current_room_id=clean_room_id: (
self._notify_room_completed(current_room_id, completed)
)
)
if event == "room":
return
if event == "status":
status = str(message.get("status", "unknown"))[:80]
self.status_changed.emit(status)
elif event == "hangup":
status = str(message.get("status", "ended"))[:80]
self.call_ended.emit(status)
self.lifecycle.end(f"companion-{status}")
self._call_cycle_closed = True
self._start_requested = False
if not self.open_im or self._shutdown_requested:
self._close_from_companion("companion-hangup")
elif event == "error":
message_text = str(message.get("message", "视频通话错误"))[:400]
self.call_error.emit(message_text)
if self._start_requested:
self.lifecycle.end("companion-error")
self._call_cycle_closed = True
self._start_requested = False
if not self.open_im or self._shutdown_requested:
self._close_from_companion("companion-error")
def _im_ai_context_is_trusted(self) -> bool:
return (
not self._closing
and not self._released
and not self._shutdown_requested
and self._injected
and self._policy.allows_main_document(self._page.url().toString())
)
def _handle_im_ai_message(self, message: Mapping[str, Any]) -> None:
if self._im_ai_context_is_trusted():
self._im_ai.handle(message)
def _flush_im_ai(self) -> None:
if not self._im_ai_context_is_trusted():
return
result = self._im_ai.take_result()
if result is not None:
payload = json.dumps(result, ensure_ascii=True, separators=(",", ":"))
self._page.runJavaScript(f"window.doctorConsultation?.imAiResult?.({payload});")
def _close_im_ai(self) -> None:
controller = getattr(self, "_im_ai", None)
if controller is not None:
controller.close()
timer = getattr(self, "_im_ai_timer", None)
if timer is not None:
timer.stop()
def _local_transcription_context_is_trusted(self) -> bool:
return (not self._closing and not self._released and self._injected
and self._policy.allows_main_document(self._page.url().toString()))
def _handle_video_assistance_message(self, message: Mapping[str, Any]) -> None:
if not self._local_transcription_context_is_trusted():
return
event = message.get("event")
if event == "video-ai-action":
if not self._shutdown_requested:
self._live_ai.handle(str(message.get("action") or ""), message.get("enabled"))
return
session_id = str(message.get("sessionId") or "")
if event == "local-transcription-start":
if (self._shutdown_requested or not self._start_requested or self._call_cycle_closed
or not self.lifecycle.call_record_id
or re.fullmatch(r"[A-Za-z0-9_-]{1,128}", session_id) is None):
return
existing = str(self.lifecycle.transcription_session_id or "")
if existing and existing != session_id:
return
was_ready = self._asr_session_id == session_id and self._asr_ready
if self._asr_session_id != session_id:
self._asr_partial = False
self._asr_ready = False
self._asr_session_id = session_id
self._live_ai.transcription_starting()
accepted = self._local_transcription.start(session_id)
if accepted and was_ready:
self._on_local_transcription({"type": "ready", "sessionId": session_id})
elif not accepted:
self._on_local_transcription({"type": "error", "sessionId": session_id,
"message": "本次转写已结束,请重新发起通话。"})
elif session_id and session_id == self._asr_session_id:
if event == "local-transcription-chunk":
if session_id != str(self.lifecycle.transcription_session_id or ""):
return
timestamp = message.get("timestamp")
if (isinstance(timestamp, bool) or not isinstance(timestamp, (int, float))
or not math.isfinite(timestamp) or not 0 < timestamp < 2**53):
return
self._local_transcription.submit(
session_id, str(message.get("role") or ""), message.get("sequence"),
int(timestamp), str(message.get("data") or ""),
)
elif event == "local-transcription-stop":
self._local_transcription.stop(session_id)
def _emit_local_transcription(self, event: dict[str, Any]) -> None:
with suppress(RuntimeError):
self._local_transcription_event.emit(event)
def _on_local_transcription(self, event: Mapping[str, Any]) -> None:
if (not self._local_transcription_context_is_trusted()
or event.get("sessionId") != self._asr_session_id):
return
kind = event.get("type")
if kind == "ready":
self._asr_ready = True
elif kind == "stopped":
self._asr_ready = False
elif kind == "segment":
role = event.get("role")
if role not in {"doctor", "patient"}:
return
self._save_transcript_segment({
"sessionId": self._asr_session_id,
"segment": {
"segment_id": event.get("segmentId"),
"speaker_role": role,
"speaker_user_id": (self.request.user_id if role == "doctor"
else self.request.target_user_id),
"timestamp": event.get("timestamp"), "text": event.get("text"),
},
})
elif kind == "error":
self._asr_partial = True
self._live_ai.transcription_error(
str(event.get("message") or "本地转写未完成"),
status="partial" if self._asr_ready else "failed",
)
payload = json.dumps(dict(event), ensure_ascii=True, separators=(",", ":"))
self._page.runJavaScript(f"window.doctorConsultation?.localTranscriptionEvent?.({payload});")
def _flush_video_ai(self) -> None:
if not self._local_transcription_context_is_trusted() or self._shutdown_requested:
return
self._live_ai.tick()
state = self._live_ai.take_state()
if state is not None:
payload = json.dumps(state, ensure_ascii=True, separators=(",", ":"))
self._page.runJavaScript(f"window.doctorConsultation?.videoAiState?.({payload});")
def _close_video_assistance(self, *, close_asr: bool = True) -> None:
controller = getattr(self, "_live_ai", None)
if controller is not None:
controller.close()
timer = getattr(self, "_video_ai_timer", None)
if timer is not None:
timer.stop()
controller = getattr(self, "_local_transcription", None)
if close_asr and controller is not None:
controller.close()
def _open_diagnosis_safely(self) -> None:
if self._closing or self._on_open_diagnosis is None:
return
try:
self._on_open_diagnosis()
except Exception:
self.logger.exception(
"diagnosis drawer could not be opened from video companion",
extra={"video_call": self.request.safe_log_context()},
)
def _notify_room_completed(self, room_id: str, future: Future[bool]) -> None:
try:
succeeded = bool(future.result())
except Exception as error:
succeeded = False
message = str(error)[:200] or "腾讯云混流视频录制未启动。"
else:
message = (
"腾讯云混流视频已启动;本机录音将在结束后另行上传 COS。"
if succeeded
else "通话房间尚未绑定,云端视频和本机录音无法关联通话记录。"
)
with suppress(RuntimeError):
self._room_completed.emit(room_id, succeeded, message)
def _on_room_completed(
self,
room_id: str,
succeeded: bool,
message: str,
) -> None:
if self._closing:
return
room_payload = json.dumps(str(room_id)[:160], ensure_ascii=True)
payload = json.dumps(str(message)[:200], ensure_ascii=True)
state = "true" if succeeded else "false"
self._page.runJavaScript(
"window.doctorConsultation?.roomBindingResult?.("
f"{room_payload}, {state}, {payload});"
)
def _emit_local_recording_result(
self,
operation: str,
session_id: str,
sequence: int,
succeeded: bool,
message: str,
) -> None:
with suppress(RuntimeError):
self._local_recording_completed.emit(
operation,
session_id,
sequence,
succeeded,
str(message)[:200],
)
def _on_local_recording_completed(
self,
operation: str,
session_id: str,
sequence: int,
succeeded: bool,
message: str,
) -> None:
if self._closing or self._released:
return
self._page.runJavaScript(
"window.doctorConsultation?.localRecordingResult?.("
f"{json.dumps(operation)}, {json.dumps(session_id)}, {sequence}, "
f"{'true' if succeeded else 'false'}, "
f"{json.dumps(str(message)[:200], ensure_ascii=True)});"
)
def _start_local_audio_recording(self, session_id: str, mime_type: str) -> None:
cleaned = str(session_id or "").strip()
clean_mime = str(mime_type or "audio/webm").strip().lower()[:120]
if not re.fullmatch(r"[A-Za-z0-9_-]{12,64}", cleaned):
self._emit_local_recording_result(
"start", cleaned, -1, False, "本地录音会话标识无效。"
)
return
if not clean_mime.startswith(("audio/webm", "audio/ogg")):
self._emit_local_recording_result(
"start", cleaned, -1, False, "当前浏览器录音格式不受支持。"
)
return
if self._local_audio_capture is not None:
existing = self._local_audio_capture.session_id == cleaned
self._emit_local_recording_result(
"start",
cleaned,
-1,
existing,
"本地录音已启动。" if existing else "已有另一条本地录音正在进行。",
)
return
try:
lifecycle = self.lifecycle
raw_call_record_id = lifecycle.call_record_id
call_record_id = (
int(raw_call_record_id) if raw_call_record_id not in (None, "") else None
)
store, uploads = get_local_audio_upload_manager(
lifecycle.repository,
self._local_audio_store,
)
self._local_audio_store = store
self._local_audio_uploads = uploads
record = store.begin_recording(
session_id=cleaned,
diagnosis_id=self.request.diagnosis_id,
mime_type=clean_mime,
call_record_id=call_record_id,
room_id=lifecycle.current_room_id or "",
)
# The handle intentionally remains open across WebChannel chunks.
handle = record.file_path.open("w+b")
except (OSError, RuntimeError, sqlite3.Error) as error:
self._emit_local_recording_result(
"start", cleaned, -1, False, str(error)[:200]
)
return
self._local_audio_capture = _LocalAudioCapture(
record_id=record.id,
session_id=cleaned,
mime_type=clean_mime,
path=record.file_path,
handle=handle,
lifecycle=lifecycle,
)
self._emit_local_recording_result(
"start", cleaned, -1, True, "本机语音录音已启动。"
)
def _append_local_audio_chunk(
self,
session_id: str,
sequence_value: Any,
encoded: str,
) -> None:
capture = self._local_audio_capture
try:
sequence = int(sequence_value)
except (TypeError, ValueError):
sequence = -1
if capture is None or session_id != capture.session_id:
self._emit_local_recording_result(
"chunk", session_id, sequence, False, "本地录音会话标识不匹配。"
)
return
if sequence != capture.next_sequence:
self._emit_local_recording_result(
"chunk", session_id, sequence, False, "本地录音分片顺序不连续。"
)
return
if not encoded or len(encoded) > 16_384:
self._emit_local_recording_result(
"chunk", session_id, sequence, False, "本地录音分片过大或为空。"
)
return
try:
content = base64.b64decode(encoded, validate=True)
except (ValueError, binascii.Error):
self._emit_local_recording_result(
"chunk", session_id, sequence, False, "本地录音分片解析失败。"
)
return
if not content or len(content) > 12 * 1024:
self._emit_local_recording_result(
"chunk", session_id, sequence, False, "本地录音分片大小无效。"
)
return
if capture.bytes_written + len(content) > 512 * 1024 * 1024:
self._emit_local_recording_result(
"chunk", session_id, sequence, False, "本地录音超过 512 MB 限制。"
)
self._abort_local_audio_recording(session_id)
return
try:
capture.handle.write(content)
except OSError as error:
self._emit_local_recording_result(
"chunk", session_id, sequence, False, str(error)[:200]
)
self._abort_local_audio_recording(session_id)
return
capture.bytes_written += len(content)
capture.next_sequence += 1
def _finish_local_audio_recording(
self, session_id: str, total_bytes_value: Any
) -> None:
capture = self._local_audio_capture
try:
total_bytes = int(total_bytes_value)
except (TypeError, ValueError):
total_bytes = -1
if capture is None or session_id != capture.session_id:
self._emit_local_recording_result(
"finish", session_id, -1, False, "本地录音会话标识不匹配。"
)
return
self._local_audio_capture = None
try:
capture.handle.flush()
os.fsync(capture.handle.fileno())
capture.handle.close()
except OSError as error:
self._mark_local_audio_invalid(capture.record_id, str(error))
self._emit_local_recording_result(
"finish", session_id, -1, False, str(error)[:200]
)
return
if total_bytes != capture.bytes_written or total_bytes <= 0:
self._mark_local_audio_invalid(
capture.record_id, "本地录音文件不完整。"
)
self._emit_local_recording_result(
"finish", session_id, -1, False, "本地录音文件不完整。"
)
return
if capture.bytes_written < 1024:
self._mark_local_audio_invalid(
capture.record_id, "本地录音文件为空或只有容器信息。"
)
self._emit_local_recording_result(
"finish",
session_id,
-1,
False,
"本地录音文件为空或只有容器信息,已阻止上传。",
)
return
try:
with capture.path.open("rb") as recording:
signature = recording.read(4)
except OSError as error:
self._mark_local_audio_invalid(capture.record_id, str(error))
self._emit_local_recording_result(
"finish", session_id, -1, False, str(error)[:200]
)
return
valid_signature = (
capture.mime_type.startswith("audio/webm")
and signature == b"\x1aE\xdf\xa3"
) or (
capture.mime_type.startswith("audio/ogg") and signature == b"OggS"
)
if not valid_signature:
self._mark_local_audio_invalid(
capture.record_id, "本地录音格式校验失败。"
)
self._emit_local_recording_result(
"finish",
session_id,
-1,
False,
"本地录音格式校验失败,已阻止上传无效文件。",
)
return
store = self._local_audio_store
uploads = self._local_audio_uploads
if store is None or uploads is None:
self._emit_local_recording_result(
"finish", session_id, -1, False, "本机录音队列尚未初始化。"
)
return
try:
store.finalize_recording(
capture.record_id,
size_bytes=capture.bytes_written,
)
except (OSError, RuntimeError, sqlite3.Error) as error:
self._mark_local_audio_invalid(capture.record_id, str(error))
self._emit_local_recording_result(
"finish", session_id, -1, False, str(error)[:200]
)
return
lifecycle = capture.lifecycle
def enqueue_upload(start_result: Future[bool] | None = None) -> None:
try:
if start_result is not None and not bool(start_result.result()):
raise RuntimeError("通话记录创建失败,录音已保存在本机,可稍后重试。")
raw_call_record_id = lifecycle.call_record_id
call_record_id = int(raw_call_record_id or 0)
if call_record_id <= 0:
raise RuntimeError("未取得通话记录编号,录音已保存在本机,可稍后重试。")
store.bind_identity(
capture.record_id,
call_record_id=call_record_id,
room_id=lifecycle.current_room_id or "",
)
uploads.submit(capture.record_id)
except Exception as error:
with suppress(Exception):
store.update_status(
capture.record_id,
"failed",
str(error)[:1000],
)
if lifecycle.call_record_id:
enqueue_upload()
else:
try:
lifecycle.start().add_done_callback(enqueue_upload)
except Exception as error:
store.update_status(
capture.record_id,
"failed",
str(error)[:1000] or "通话记录创建失败。",
)
self._emit_local_recording_result(
"finish",
session_id,
-1,
True,
"本地录音已保存,正在后台上传 COS。",
)
def _mark_local_audio_invalid(self, record_id: int, message: str) -> None:
store = self._local_audio_store
if store is None:
return
with suppress(Exception):
store.mark_invalid(record_id, message)
def _abort_local_audio_recording(self, session_id: str) -> None:
capture = self._local_audio_capture
if capture is None or (session_id and capture.session_id != session_id):
return
self._local_audio_capture = None
with suppress(OSError):
capture.handle.flush()
capture.handle.close()
self._mark_local_audio_invalid(
capture.record_id,
"本次本地录音未正常结束,文件已保留以便排查。",
)
def _prepare_call_cycle(self) -> None:
if self._call_cycle_closed:
self.lifecycle = self._lifecycle_factory()
self._lifecycles.append(self.lifecycle)
self._call_cycle_closed = False
def _refresh_call_policy(self, request_id: str) -> None:
if not request_id or self._closing or self._shutdown_requested:
return
self._prepare_call_cycle()
def completed(future: Future[dict[str, Any]]) -> None:
try:
policy = future.result()
except Exception:
policy = {"call_disabled_reason": "无法确认本次挂号通话权限,请重新打开聊天窗口"}
with suppress(RuntimeError):
self._policy_completed.emit(request_id, policy)
try:
self.lifecycle.refresh_call_policy().add_done_callback(completed)
except Exception:
self._on_policy_completed(request_id, {})
def _on_policy_completed(self, request_id: str, policy: dict[str, Any]) -> None:
if self._closing or self._shutdown_requested or self._released:
return
# Send policy only; refreshed credentials never enter logs or notices.
payload = {key: policy.get(key) for key in (
"appointmentId", "appointment_type", "can_video_call", "can_audio_call",
"call_disabled_reason", "appointment_type_desc",
)}
self._page.runJavaScript(
"window.doctorConsultation?.callPolicyResult?.("
+ json.dumps(request_id) + "," + json.dumps(payload, ensure_ascii=True) + ");"
)
def _start_call_cycle(self, *, call_type: int = 2) -> None:
if self._closing or self._shutdown_requested or self._start_requested:
return
self._prepare_call_cycle()
live_ai = getattr(self, "_live_ai", None)
if live_ai is not None:
live_ai.reset()
self._asr_session_id = ""
self._asr_ready = False
self._asr_partial = False
self._start_requested = True
try:
future = self.lifecycle.start(call_type=call_type)
except Exception:
self._start_requested = False
self._on_lifecycle_started(False)
return
future.add_done_callback(self._notify_start_completed)
def _set_screenshot_preview_visible(self, visible: bool) -> None:
if self._closing or self._released:
return
if not self._policy.allows_main_document(self._page.url().toString()):
return
if not visible:
self.restore_screenshot_preview()
return
if self._shutdown_requested or not self._media_active:
return
from ..ui.theme import main_window_target_rect
self._screenshot_preview_size.open(self, main_window_target_rect(self))
def restore_screenshot_preview(self) -> None:
self._screenshot_preview_size.restore(self)
def _capture_screenshot_preview(self, region: Mapping[str, Any]) -> str:
if self._closing or self._released or self._shutdown_requested or not self._media_active:
raise ValueError("视频窗口已关闭。")
if not self._policy.allows_main_document(self._page.url().toString()):
raise ValueError("视频页面不可用。")
return capture_view_region(self.web_view, region)
def _save_screenshot(self, data_url: str) -> None:
prefix = "data:image/jpeg;base64,"
if not data_url.startswith(prefix):
self._on_screenshot_completed(False, "截屏图片格式不正确。")
return
try:
content = base64.b64decode(data_url[len(prefix) :], validate=True)
except (ValueError, binascii.Error):
self._on_screenshot_completed(False, "截屏图片解析失败。")
return
try:
future = self.lifecycle.save_screenshot(
content,
f"callshot-{self.request.diagnosis_id}.jpg",
)
except Exception as error:
self._on_screenshot_completed(False, str(error)[:200])
return
future.add_done_callback(self._notify_screenshot_completed)
def _notify_screenshot_completed(self, future: Future[str]) -> None:
try:
future.result()
except Exception as error:
succeeded = False
message = str(error)[:200] or "截屏保存失败。"
else:
succeeded = True
message = "截屏已保存到患者信息。"
with suppress(RuntimeError):
self._screenshot_completed.emit(succeeded, message)
def _on_screenshot_completed(self, succeeded: bool, message: str) -> None:
payload = json.dumps(str(message)[:200], ensure_ascii=True)
state = "true" if succeeded else "false"
self._page.runJavaScript(
f"window.doctorConsultation?.screenshotResult?.({state}, {payload});"
)
def _notify_transcription_completed(
self,
operation: str,
session_id: str,
segment_id: str,
future: Future[bool],
normalized_segment: Mapping[str, Any] | None = None,
) -> None:
try:
succeeded = bool(future.result())
except Exception as error:
succeeded = False
message = str(error)[:200] or "录音文字保存失败。"
else:
message = {
"start": "录音文字存储已准备。",
"segment": "",
"stop": "本次面诊对话文字已保存。",
}.get(operation, "")
with suppress(RuntimeError):
self._transcription_completed.emit(
operation, session_id, segment_id, succeeded, message,
json.dumps(normalized_segment if succeeded else None, ensure_ascii=True),
)
def _on_transcription_completed(
self,
operation: str,
session_id: str,
segment_id: str,
succeeded: bool,
message: str,
normalized_segment: str | Mapping[str, Any] | None = None,
) -> None:
if not self._local_transcription_context_is_trusted():
return
live_ai = getattr(self, "_live_ai", None)
if (live_ai is not None
and session_id == str(self.lifecycle.transcription_session_id or "")):
if operation == "start" and succeeded:
live_ai.bind(int(self.lifecycle.call_record_id), session_id)
elif operation == "start":
live_ai.transcription_error(message or "转写文字存储未就绪,请重试。", status="failed")
elif operation == "segment":
if succeeded:
live_ai.changed(session_id)
else:
self._asr_partial = True
live_ai.transcription_error("部分对话文字保存失败,分析资料可能不完整。")
elif operation == "stop":
live_ai.finish(session_id, self._transcription_final_status if succeeded else "partial")
payload = json.dumps(str(message)[:200], ensure_ascii=True)
state = "true" if succeeded else "false"
if isinstance(normalized_segment, str):
try:
normalized_segment = json.loads(normalized_segment)
except (ValueError, TypeError):
normalized_segment = None
caption = json.dumps(
dict(normalized_segment)
if succeeded and operation == "segment" and isinstance(normalized_segment, Mapping)
else None,
ensure_ascii=True,
)
self._page.runJavaScript(
"window.doctorConsultation?.transcriptionResult?.("
f"{json.dumps(operation)}, {json.dumps(session_id)}, "
f"{json.dumps(segment_id)}, {state}, {payload}, {caption});"
)
def _start_transcription(self, session_id: str, language: str) -> None:
if not self._local_transcription_context_is_trusted() or self._shutdown_requested:
return
try:
future = self.lifecycle.start_transcription(session_id, language=language)
except Exception as error:
self._on_transcription_completed(
"start", session_id, "", False, str(error)[:200]
)
return
self._live_ai.transcription_starting()
future.add_done_callback(
lambda completed: self._notify_transcription_completed(
"start", session_id, "", completed
)
)
def _save_transcript_segment(self, message: Mapping[str, Any]) -> None:
if not self._local_transcription_context_is_trusted():
return
session_id = str(message.get("sessionId") or "").strip()
segment = message.get("segment")
segment_id = (
str(segment.get("segment_id") or segment.get("segmentId") or "").strip()
if isinstance(segment, Mapping)
else ""
)
if not isinstance(segment, Mapping):
self._on_transcription_completed(
"segment", session_id, segment_id, False, "录音文字片段无效。"
)
return
if session_id != str(self.lifecycle.transcription_session_id or ""):
self._on_transcription_completed(
"segment", session_id, segment_id, False, "录音会话标识不匹配。"
)
return
try:
normalized = normalize_transcript_segment(segment, session_id)
speaker = normalized["speaker_user_id"]
normalized["speaker_role"] = (
"doctor" if speaker == self.request.user_id
else "patient" if speaker == self.request.target_user_id
else "unknown"
)
future = self.lifecycle.save_transcript_segment(normalized)
except Exception as error:
self._on_transcription_completed(
"segment", session_id, segment_id, False, str(error)[:200]
)
return
caption = {
"segmentId": normalized["segment_id"],
"speakerUserId": normalized["speaker_user_id"],
"sourceText": normalized["text"],
"timestamp": normalized["timestamp"],
"isCompleted": True,
}
future.add_done_callback(
lambda completed: self._notify_transcription_completed(
"segment", session_id, segment_id, completed, caption
)
)
def _finish_transcription(self, session_id: str, status: str) -> None:
if not self._local_transcription_context_is_trusted():
return
if session_id.strip() != str(self.lifecycle.transcription_session_id or ""):
self._on_transcription_completed(
"stop", session_id, "", False, "录音会话标识不匹配。"
)
return
try:
if getattr(self, "_asr_partial", False):
status = "partial"
self._transcription_final_status = status
future = self.lifecycle.finish_transcription(status=status)
except Exception as error:
self._on_transcription_completed(
"stop", session_id, "", False, str(error)[:200]
)
return
future.add_done_callback(
lambda completed: self._notify_transcription_completed(
"stop", session_id, "", completed
)
)
def _close_from_companion(self, reason: str) -> None:
self._companion_ended = True
self._close_reason = reason
self.close()
def hangup(self) -> None:
self._request_companion_shutdown("desktop-hangup")
def set_compact_close_handler(self, callback: Callable[[], None] | None) -> None:
"""Let the compact title-bar close return to the same full call window."""
self._on_compact_close = callback
def _request_companion_shutdown(self, reason: str) -> None:
"""Let MediaRecorder finish and upload before WebEngine is destroyed."""
_EmbeddedVideoWindow._close_im_ai(self)
_EmbeddedVideoWindow._close_video_assistance(self, close_asr=False)
self._close_reason = reason
if self._closing or self._released:
return
should_wait_for_companion = (
self._injected
and self._start_requested
and not self._call_cycle_closed
and not self._companion_ended
)
if not should_wait_for_companion:
self._shutdown_requested = True
self.close()
return
if self._shutdown_requested:
return
self._shutdown_requested = True
# doctorConsultation.close() stops MediaRecorder, drains every queued
# WebChannel chunk, waits for the Qt/COS finish acknowledgement, and
# only then emits hangup. Keeping _closing false here is essential:
# bridge callbacks are deliberately rejected once final destruction
# begins.
self._page.runJavaScript(
"void window.doctorConsultation?.close?.().catch(() => undefined)"
)
self._shutdown_timer.start(190_000)
def _force_requested_shutdown(self) -> None:
"""Bound a failed companion shutdown without racing queued uploads."""
if not self._shutdown_requested or self._closing or self._released:
return
if self._start_requested and not self._call_cycle_closed:
# OrderedCallLifecycle places end after any upload that already
# reached the Qt bridge.
self.lifecycle.end(f"{self._close_reason}-timeout")
self._call_cycle_closed = True
self._start_requested = False
self._abort_local_audio_recording("")
self._companion_ended = True
self.close()
def _begin_shutdown(self) -> None:
if self._closing:
return
_EmbeddedVideoWindow._close_im_ai(self)
_EmbeddedVideoWindow._close_video_assistance(self)
self._on_compact_close = None
self._closing = True
self._media_active = False
self._shutdown_timer.stop()
# Also retire policy-only workers for IM sessions without a live call.
self.lifecycle.end(self._close_reason)
self._abort_local_audio_recording("")
self._release_webengine()
def wait_for_lifecycles(self, timeout: float) -> bool:
return all(lifecycle.wait(timeout) for lifecycle in self._lifecycles)
def _release_webengine(self) -> None:
if self._released:
return
self._released = True
policies = QWebEnginePage.PermissionPolicy
for origin, feature in self._legacy_grants:
with suppress(RuntimeError):
self._page.setFeaturePermission(
origin,
feature,
policies.PermissionDeniedByUser,
)
self._legacy_grants.clear()
for permission in self._permission_grants:
try:
if permission.isValid():
permission.reset()
except RuntimeError:
pass
self._permission_grants.clear()
try:
self._channel.deregisterObject(self._bridge)
self._page.setWebChannel(None)
except RuntimeError:
pass
try:
self._profile.cookieStore().deleteAllCookies()
self._profile.clearHttpCache()
self._profile.clearAllVisitedLinks()
except RuntimeError:
pass
try:
self._page.begin_shutdown()
self._page.setUrl(QUrl("about:blank"))
except RuntimeError:
pass
view = self.takeCentralWidget()
if view is not None:
view.close()
view.deleteLater()
self._page.deleteLater()
self._profile.deleteLater()
def closeEvent(self, event: Any) -> None:
if (
self._on_compact_close is not None
and not self._shutdown_requested
and not self._companion_ended
and not self._closing
and not self._released
):
event.ignore()
self._on_compact_close()
return
if (
self._injected
and self._start_requested
and not self._call_cycle_closed
and not self._companion_ended
):
event.ignore()
self._request_companion_shutdown(self._close_reason)
return
self._begin_shutdown()
event.accept()
else:
_EmbeddedVideoWindow = None # type: ignore[assignment, misc]
class VideoCallWindow:
"""Facade for the only currently supported backend: embedded QtWebEngine."""
def __init__(
self,
request: VideoCallRequest,
*,
repository: Any,
local_dist: str | Path | None = None,
remote_url: str | None = None,
logger: logging.Logger | None = None,
browser_opener: Callable[[str], bool] | None = None,
open_im: bool = False,
patient_name: str = "患者",
patient_case: Mapping[str, Any] | None = None,
on_open_diagnosis: Callable[[], None] | None = None,
can_ai_assistant: bool = False,
) -> None:
del browser_opener # Reserved for a future authenticated handoff implementation.
try:
self.backend_mode = require_supported_backend(request.backend_mode)
except VideoTicketError as error:
raise VideoWindowError(str(error)) from error
if not WEBENGINE_AVAILABLE:
raise VideoWindowError(
"embedded video is unavailable and automatic browser fallback is disabled"
)
if QApplication is None or QApplication.instance() is None:
raise VideoWindowError("embedded video requires an active QApplication")
self.request = request
self.repository = repository
self.open_im = bool(open_im)
self.patient_name = str(patient_name or "患者").strip() or "患者"
self.patient_case = dict(patient_case or {})
self.can_ai_assistant = can_ai_assistant is True
self.on_open_diagnosis = on_open_diagnosis
self.logger = logger or _LOGGER
self.location = resolve_companion_location(
local_dist=local_dist,
remote_url=remote_url,
)
self.lifecycle = OrderedCallLifecycle(request, repository, self.logger)
self._lifecycles = [self.lifecycle]
self._session: Any = None
def _new_lifecycle(self) -> OrderedCallLifecycle:
lifecycle = OrderedCallLifecycle(self.request, self.repository, self.logger)
self._lifecycles.append(lifecycle)
return lifecycle
@property
def qt_window(self) -> Any:
return self._session
def open(self) -> VideoCallWindow:
try:
self._session = _EmbeddedVideoWindow(
self.request,
self.location,
self.lifecycle,
logger=self.logger,
lifecycle_factory=self._new_lifecycle,
open_im=self.open_im,
patient_name=self.patient_name,
patient_case=self.patient_case,
on_open_diagnosis=self.on_open_diagnosis,
can_ai_assistant=self.can_ai_assistant,
repository=self.repository,
)
except Exception:
self.lifecycle.end("window-open-failed")
raise
self._session.show()
self._session.raise_()
self._session.activateWindow()
return self
show = open
def hangup(self) -> None:
if self._session is not None:
self._session.hangup()
else:
self.lifecycle.end("unopened-session")
def close(self) -> None:
if self._session is not None:
self._session._request_companion_shutdown("window-closed")
else:
self.lifecycle.end("unopened-session")
def wait_for_lifecycle(self, timeout: float = 0.25) -> bool:
"""Wait briefly for ordered backend writes; timeout is capped at five seconds."""
if self._session is not None:
return self._session.wait_for_lifecycles(timeout)
return all(lifecycle.wait(timeout) for lifecycle in self._lifecycles)
wait = wait_for_lifecycle
def open_video_call(
request: VideoCallRequest,
*,
repository: Any,
local_dist: str | Path | None = None,
remote_url: str | None = None,
logger: logging.Logger | None = None,
browser_opener: Callable[[str], bool] | None = None,
open_im: bool = False,
patient_name: str = "患者",
patient_case: Mapping[str, Any] | None = None,
on_open_diagnosis: Callable[[], None] | None = None,
can_ai_assistant: bool = False,
) -> VideoCallWindow:
"""Create and immediately open a trusted embedded video window."""
if not isinstance(request, VideoCallRequest):
raise VideoTicketError("request must be a VideoCallRequest")
return VideoCallWindow(
request,
repository=repository,
local_dist=local_dist,
remote_url=remote_url,
logger=logger,
browser_opener=browser_opener,
open_im=open_im,
patient_name=patient_name,
patient_case=patient_case,
on_open_diagnosis=on_open_diagnosis,
can_ai_assistant=can_ai_assistant,
).open()
__all__ = [
"CompanionLocation",
"TrustedDocumentPolicy",
"VideoCallWindow",
"VideoWindowError",
"WEBENGINE_AVAILABLE",
"open_video_call",
"resolve_companion_location",
"webengine_unavailable_reason",
]