Doubao-powered voice input for Linux, Wayland and Omarchy
"""Runtime assembly, preferences and update lifecycle."""
from __future__ import annotations
import logging
import signal
import shutil
from threading import Thread
from dataclasses import replace
import gi
gi.require_version("Gtk", "4.0")
from gi.repository import Gio, GLib, Gtk # type: ignore
from doubao_input.doubao.app_state import AppState, LoginStatus, RecordingState
from doubao_input.doubao.audio_capture import AudioCapture
from doubao_input.inject.delivery import Delivery
from doubao_input.inject.target import focused_target
from doubao_input.result import RecentResult
from doubao_input.doubao.params_store import ParamsStore
from doubao_input.doubao.transcription import TranscriptionManager
from doubao_input.inject.injector import Injector
from doubao_input.trigger.reader import TriggerReader
from doubao_input.trigger.controller import TriggerController
from doubao_input.setup_session import SetupSession
from doubao_input.inject.worker import InputWorker
from doubao_input.preferences import apply_preferences
from doubao_input.settings import (Settings, canonical_shortcut,
key_codes_match, trigger_shortcut_display)
from doubao_input.i18n import set_language, tr
from doubao_input.ui.control_window import ControlWindow
from doubao_input.ui.setup_actions import SetupActions
from doubao_input.ui.overlay import Overlay
from doubao_input.polish import ApiKeyStore, PolishManager
from doubao_input.updates import UpdateChecker
from doubao_input.update_install import prepare as prepare_update, launch as launch_update, consume_result as consume_update_result
from doubao_input.polish_preview import PolishPreview
from doubao_input.trigger.escape_guard import EscapeGuard
from doubao_input.diagnostics import DiagnosticTrace, report as diagnostic_report
from doubao_input.recognition_providers import recognition_provider
logger = logging.getLogger(__name__)
def _application_class():
from doubao_input.app import DoubaoInputApp
return DoubaoInputApp
class RuntimeMixin:
def _on_shutdown(self, _app) -> None:
from doubao_input.chatgpt import close_chatgpt
close_chatgpt()
logger.info("shutting down")
if self._escape_timer is not None:
GLib.source_remove(self._escape_timer)
self._escape_timer = None
if self._escape_guard:
self._escape_guard.close()
if self._tray:
self._tray.close()
self._tray = None
if self._tm:
self._tm.audio_capture.stop()
self._tm.asr_client.disconnect()
if self._setup_session:
self._setup_session.dismiss()
if self._triggers:
self._triggers.close()
if self._delivery:
self._delivery.close(self._injector.close)
if self._polisher:
self._polisher.close()
if getattr(self, "_asr_probe", None):
self._asr_probe.disconnect()
self._asr_probe = None
if self._update_checker:
self._update_checker.close()
if self._update_timer:
GLib.source_remove(self._update_timer)
self._update_timer = None
def _build(self) -> None:
self._overlay = Overlay(self.app_state)
self._injector = Injector()
self._delivery = Delivery(GLib.timeout_add, focused_target,
lambda text, target, cancelled: self._injector.inject(text, expected_target=target, cancelled=cancelled,
method=self.settings.input_method),
lambda target, cancelled: self._injector.send_enter(expected_target=target, cancelled=cancelled),
self._delivery_changed, InputWorker(GLib.idle_add))
self._polisher = PolishManager(GLib.idle_add)
# ---- TranscriptionManager (state machine) ----
tm = self._new_transcription_manager()
# Replace its audio_capture with our instance so we can wire RMS
self._audio_capture = AudioCapture(on_rms=self._on_audio_rms)
self._audio_capture.device = self.settings.microphone
self._overlay.reduced_motion = self.settings.reduced_motion
self._overlay.waveform_style = self.settings.waveform_style
tm.audio_capture = self._audio_capture
tm.on_show_login = self._prompt_recognition_setup
tm.on_overlay_show = lambda: self._overlay.show(tr("Starting voice recognition…", "正在启动语音识别…"))
tm.on_overlay_hide = self._hide_recording_overlay
tm.on_overlay_update = self._recording_text_updated
tm.on_paste = self._do_paste
tm.on_empty_complete = self._empty_complete
tm.on_recover = self._recover_partial
tm.on_cancel_enabled_changed = lambda enabled: None
tm.on_auth_expired = self._on_auth_expired
tm.on_service_error = self._on_service_error
tm.on_params_needed = self._provide_params
tm.on_diagnostic = self._trace_input
self._tm = tm
# ---- Control window ----
self._control = ControlWindow(
app_state=self.app_state,
on_login_clicked=self._connect_recognition,
on_quit_clicked=self._quit,
on_check_mic_clicked=self._check_mic,
app=self,
actions=SetupActions(
test_voice=self._test_voice,
cancel_preview=self._cancel_voice_test,
open_settings=self._show_settings,
is_preview_testing=lambda: self._preview_testing,
summary=self._summary,
complete_setup=self._complete_setup,
apply_key=self._apply_trigger_key,
capture_key=self._begin_key_capture,
cancel_key_capture=self._end_key_capture,
polish_settings=lambda: self.settings,
polish_has_key=self._polish_has_key,
save_polish=self._save_polish,
test_polish=self._test_polish,
apply_microphone=self._apply_microphone,
apply_asr_provider=self._apply_asr_provider,
asr_has_key=self._api_key_has_saved,
save_asr=self._save_asr_key,
test_asr=self._test_asr_key,
check_updates=lambda: self._update_checker.check(force=True),
install_update=self._install_update,
open_personal=self._show_personal,
),
)
self._update_checker = UpdateChecker(GLib.idle_add, self._update_available, status=self._update_status)
try:
self._personal_store.history(limit=0)
except Exception:
self._control.set_feedback(tr("Could not open local input history.", "无法打开本地输入历史。"))
self._update_checker.check()
update_result = consume_update_result()
if update_result and not update_result["success"]:
self.app_state.error_message = tr("The previous update failed. The previous installation was restored; details are in the update log.", "上次更新失败,已恢复旧安装;详情保存在更新日志中。")
self._update_timer = GLib.timeout_add_seconds(3600, self._check_updates)
self._setup_session = SetupSession(self._audio_capture, self._overlay,
self._control.set_feedback, self._control.set_preview, tm.handle_cancel,
GLib.timeout_add, GLib.source_remove, self._control.refresh)
self._escape_guard = EscapeGuard(lambda message: self._control.set_feedback(
tr("Could not protect Escape: ", "无法拦截 Esc:") + message))
self._escape_timer = GLib.timeout_add(50, self._sync_escape)
self._triggers = TriggerController(TriggerReader, GLib.timeout_add, GLib.source_remove,
escape_edge=self._escape_guard.edge,
start=self._voice_start, stop=self._voice_stop, toggle=self._voice_toggle,
enter=self._voice_enter, cancel_input=self._cancel_input,
shortcut=self._injector.send_shortcut,
prime=self._voice_prime, discard=self._tm.discard_primed_audio,
is_recording=lambda: self.app_state.is_recording,
debug_edge=self._debug_edge, error=lambda message: logger.warning("PTT error: %s", message))
# ---- Initial state: cached params? ----
self._sync_recognition_status()
# ---- PTT trigger ----
from doubao_input.ui.tray import Tray
try:
self._tray = Tray(self.app_state, self._control.show, menu_entries=[
(lambda: tr("Open control center", "打开控制中心"), self._control.show),
(lambda: tr("Settings", "设置"), lambda: (self._control.show(), self._show_settings())),
(lambda: tr("Check microphone", "检查麦克风"), self._check_mic),
(lambda: tr("Copy recent result", "复制最近结果"), self._copy_recent),
(lambda: tr("Cancel recording / input", "取消录音或输入"), self._cancel_input),
])
except GLib.Error:
logger.exception("System tray unavailable; desktop launcher remains usable")
self._triggers.configure(self.settings)
if self._trigger_debug_requested:
from doubao_input.ui.trigger_debug import TriggerDebug
self._debug_session = TriggerDebug(self, self._exit_trigger_debug)
logger.info("build complete")
def _exit_trigger_debug(self):
if self._debug_session:
session, self._debug_session = self._debug_session, None
session.close()
return True
def _update_available(self, info):
self._control.set_update(info)
self._overlay.set_update(info)
def _update_status(self, value):
if self._update_installing:
return
if value == "current":
self._control.set_update(None); self._overlay.set_update(None)
messages = {
"checking": tr("Checking for updates…", "正在检查更新…"),
"current": tr("You are using the latest version.", "当前已是最新版本。"),
"available": tr("Update available. Click Update to download and restart.", "发现新版本,点击更新即可下载并重启。"),
"failed": tr("Could not check for updates. Try again later.", "更新检查失败,请稍后重试。"),
}
self._control.set_update_status(messages[value], value == "checking")
def _install_update(self, info):
if self._update_installing:
return
if self._busy():
self._control.set_feedback(tr("Finish dictation or testing before updating.", "请先结束听写或测试,再安装更新。"))
return
if not self._control.flush_edits() or (self._settings_window and not self._settings_window.flush_edits()) or (self._personal_window and not self._personal_window.flush()):
self._control.set_feedback(tr("Correct unsaved settings before updating.", "请先修正未保存的设置,再更新。"))
return
self._update_installing = True
self._control.set_update_status(tr("Downloading update…", "正在下载更新…"), True)
def prepared(scratch, error):
self._update_installing = False
if error or self._busy():
if scratch:
shutil.rmtree(scratch)
self._control.set_update_status(tr("Update was not installed: ", "更新未安装:") + (error or tr("finish dictation first", "请先结束听写")))
return False
if not self._control.flush_edits() or (self._settings_window and not self._settings_window.flush_edits()) or (self._personal_window and not self._personal_window.flush()):
shutil.rmtree(scratch)
self._control.set_update_status(tr("Correct unsaved settings before updating.", "请先修正未保存的设置,再更新。"))
return False
try:
launch_update(scratch)
except OSError:
shutil.rmtree(scratch)
self._control.set_update_status(tr("Could not start the updater; the installed app is unchanged.", "无法启动更新程序,已安装的应用未改变。"))
return False
self._quit()
return False
def worker():
scratch = None
try:
def status(message):
phases = {
"Downloading release source…": tr("Downloading release source…", "正在下载更新源码…"),
"Downloading update…": tr("Downloading update…", "正在下载更新…"),
"Verifying update…": tr("Verifying update…", "正在核验更新包…"),
}
GLib.idle_add(lambda: self._control.set_update_status(phases.get(message, message), True))
scratch = prepare_update(info, status=status)
error = None
except Exception as exc:
logger.info("Update preparation failed (%s)", type(exc).__name__)
message = str(exc)
if "Local changes exist" in message:
error = tr("Local source changes exist. Commit or move them before updating.", "源码中有本地修改,请先提交或移走,再更新。")
elif "package manager" in message:
error = tr("Use your package manager to update this installation.", "此安装由系统包管理器管理,请通过包管理器更新。")
elif "Release is missing" in message:
error = tr("No update package matches this CPU and Python version.", "此版本没有匹配当前 CPU 和 Python 的更新包。")
else:
error = tr("Check the connection, release package and installation permissions.", "请检查网络、更新包和安装目录权限。")
GLib.idle_add(prepared, scratch, error)
Thread(target=worker, name="doubao-update-download", daemon=True).start()
def _remember_input(self, original, output, polished):
store = getattr(self, "_personal_store", None)
if not store:
return
try:
self._history_id = store.record(original, output, polished)
except Exception:
self._history_id = None
self._control.set_feedback(tr("Could not save local input history. Input is still available.", "本地输入历史保存失败,文字仍可输入。"))
def _can_evaluate_speech(self):
audio = getattr(self, "_audio_capture", None)
# A held gesture may be buffering audio while the visible state is idle.
return not self._busy() and not (audio and audio.is_capturing)
def _show_personal(self):
from doubao_input.ui.personal_window import PersonalWindow
if self._personal_window is None:
self._personal_window = PersonalWindow(self._personal_store, lambda: self.settings, self._polish_key, self.recent, self._retry_recent, self._can_evaluate_speech)
self._personal_window.show()
def _check_updates(self):
try:
self._personal_store.history(limit=0)
except Exception:
logger.warning("Could not prune local history")
self._update_checker.check()
return True
def _debug_edge(self, code, pressed):
if not self._debug_session:
return False
if key_codes_match(code, self.settings.doubao_key):
self._debug_session.edge(pressed)
return True
def _apply_trigger_key(self, key, modifiers=()):
from dataclasses import replace
key, modifiers = canonical_shortcut(key, modifiers)
self.apply_settings(replace(self.settings, doubao_key=key,
doubao_modifiers=modifiers))
def _apply_microphone(self, device):
from dataclasses import replace
self.apply_settings(replace(self.settings, microphone=device))
def _apply_asr_provider(self, provider):
from dataclasses import replace
self.apply_settings(replace(self.settings, asr_provider=provider))
def apply_settings(self, settings):
settings.validate()
if settings.autostart and "/omarchy/plugins/" in __file__:
raise ValueError(tr("This installation is started by Omarchy. Disable plugin startup before using a standalone autostart installation.",
"当前安装由 Omarchy 插件启动。请勿同时启用独立应用自启动。"))
if self._busy() or self._triggers.busy:
raise ValueError(tr("Finish the current operation and release the trigger before saving", "请先结束当前操作并松开触发键,再保存设置"))
previous = self.settings
if previous.asr_provider != settings.asr_provider:
# A modal Settings window can open while onboarding's debounce is
# pending. Both drafts still belong to the provider being left.
for view in (self._control, self._settings_window):
if view and not view._flush_asr_key():
raise ValueError(tr(
"Save the current API key before switching services.",
"请先保存当前 API Key,再切换识别服务。"))
def apply_runtime(value, strict):
self._triggers.configure(value, strict=strict)
self._audio_capture.device = value.microphone
self._overlay.reduced_motion = value.reduced_motion
self._overlay.waveform_style = value.waveform_style
apply_preferences(previous, settings,
lambda value: apply_runtime(value, True),
lambda value: apply_runtime(value, False))
self.settings = settings
if previous.asr_provider != settings.asr_provider:
self._configure_recognition_backend()
self._sync_recognition_status()
self._setup_session.voice_ok = False
if previous.microphone != settings.microphone:
self._setup_session.microphone_ok = self._setup_session.voice_ok = False
self._control.refresh()
def _trace_input(self, stage):
self._diagnostics.add(stage)
if stage == "gesture_confirmed":
self._input_latency.reset()
elif stage == "stop_requested":
self._input_latency.stop()
def _new_transcription_manager(self):
provider = recognition_provider(self.settings.asr_provider)
return TranscriptionManager(
self.app_state,
asr_client=provider.new_client(),
credential_store=provider.credential_store,
interactive_auth=provider.interactive_auth,
clear_rejected_credentials=provider.clear_rejected_credentials,
)
def _configure_recognition_backend(self):
if self._asr_probe:
self._asr_probe.disconnect()
self._asr_probe = None
provider = recognition_provider(self.settings.asr_provider)
self._tm.configure_backend(
provider.new_client(),
provider.credential_store,
interactive_auth=provider.interactive_auth,
clear_rejected_credentials=provider.clear_rejected_credentials,
)
def _recognition_ready(self):
try:
return recognition_provider(
self.settings.asr_provider
).credential_store.has_saved()
except (OSError, ValueError):
return False
def _sync_recognition_status(self):
self.app_state.login_status = (LoginStatus.LOGGED_IN if self._recognition_ready()
else LoginStatus.NOT_LOGGED_IN)