Doubao-powered voice input for Linux, Wayland and Omarchy
"""Grouped preferences, safe hardware-key capture and allowlisted diagnostics."""
from dataclasses import replace
from gi.repository import GLib, Gtk, Gdk
from doubao_input.ui.trigger_picker import TriggerPicker
from doubao_input.i18n import LANGUAGES, tr
from doubao_input.doubao.devices import microphones
from doubao_input.diagnostics import report
from doubao_input.product import VERSION
from doubao_input.settings import INPUT_METHODS, WAVEFORM_STYLES
from doubao_input.ui.style import apply_window_style
from doubao_input.settings import ASR_PROVIDERS
from doubao_input.recognition_providers import (
recognition_provider,
recognition_providers,
)
class SettingsWindow:
def __init__(self, parent, settings, apply, *, capture_key=None,
cancel_capture=lambda: None, sign_out=lambda: None,
restart=lambda: None, login=lambda: None, preview=lambda: None,
apply_key=None, asr_has_key=lambda: False,
save_asr=lambda key: None, clear_asr=lambda: None,
test_asr=lambda key, completed: None,
diagnostic_report=None):
self.window = Gtk.Window(title=tr("Doubao Say Settings", "豆包说设置"), transient_for=parent, modal=True)
self.window.set_default_size(540, 580)
apply_window_style(self.window)
self._settings = settings
self._apply = apply
self._restart = restart
self._updating = False
self._asr_has_key = asr_has_key()
self._asr_has_key_func = asr_has_key
self._save_asr = save_asr
self._clear_asr = clear_asr
self._test_asr = test_asr
self._asr_save_source = 0
self._asr_testing = False
self._diagnostic_report = diagnostic_report or (lambda: report(self._settings))
self.window.connect("close-request", self._close)
root = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
for side in ("start", "end", "top", "bottom"):
getattr(box, "set_margin_" + side)(24)
scroll = Gtk.ScrolledWindow(vexpand=True)
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scroll.set_child(box)
root.append(scroll)
self.window.set_child(root)
self.status = Gtk.Label(xalign=0, wrap=True)
status = self.status
def section(title):
label = Gtk.Label(label=title, xalign=0)
label.add_css_class("settings-section-title")
box.append(label)
def row(label, widget):
line = Gtk.Box(spacing=12)
line.add_css_class("settings-row")
text = Gtk.Label(label=label, xalign=0, hexpand=True, wrap=True)
line.append(text)
line.append(widget)
box.append(line)
widget.set_tooltip_text(label)
return widget
def button(title, callback):
widget = Gtk.Button(label=title)
def run(*_):
try:
callback()
except (ValueError, OSError) as error:
status.set_text(str(error))
widget.connect("clicked", run)
box.append(widget)
return widget
section(tr("Doubao Say Settings", "豆包说设置"))
section(tr("General", "通用"))
self.language = Gtk.DropDown.new_from_strings([tr("System", "跟随系统"), "English", "简体中文"])
self.language.set_selected(LANGUAGES.index(settings.language))
row(tr("Language", "界面语言"), self.language)
self.autostart = row(tr("Start in background at login", "登录桌面后后台启动"),
Gtk.Switch(active=settings.autostart))
section(tr("Audio", "音频"))
self.sources = [("", tr("System default", "系统默认"))]
if settings.microphone:
self.sources.append((settings.microphone, tr(
"Saved device (unavailable)", "已保存设备(当前不可用)")))
self.microphone = Gtk.DropDown.new_from_strings(
[label for _, label in self.sources])
self.microphone.set_selected(
[key for key, _ in self.sources].index(settings.microphone))
self.microphone.set_hexpand(True)
microphone_controls = Gtk.Box(spacing=8)
microphone_controls.append(self.microphone)
self.microphone_refresh = Gtk.Button(label=tr(
"Refresh devices", "刷新设备"))
self.microphone_refresh.connect(
"clicked", lambda *_: self._refresh_microphones(announce=True))
microphone_controls.append(self.microphone_refresh)
row(tr("Microphone", "麦克风"), microphone_controls)
box.append(Gtk.Label(xalign=0, wrap=True, label=tr(
"Changes save automatically. Choose System default to follow the desktop input device.",
"更改会自动保存;选择“系统默认”可跟随桌面的输入设备。")))
section(tr("Recognition service", "语音识别服务"))
self.asr_provider = Gtk.DropDown.new_from_strings(
[provider.name for provider in recognition_providers()])
self.asr_provider.set_selected(ASR_PROVIDERS.index(settings.asr_provider))
row(tr("Service", "服务"), self.asr_provider)
self.asr_details = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
self.asr_key = Gtk.Entry(visibility=False, hexpand=True)
self.asr_key.set_invisible_char("•")
self.asr_key.set_placeholder_text(tr(
"Saved — leave blank to keep" if self._asr_has_key else "Enter speech API key",
"已保存,留空则保持不变" if self._asr_has_key else "填写语音 API Key"))
key_row = Gtk.Box(spacing=12)
key_row.add_css_class("settings-row")
key_row.append(Gtk.Label(label="API Key", xalign=0, hexpand=True, wrap=True))
key_row.append(self.asr_key)
self.asr_details.append(key_row)
selected_provider = recognition_provider(settings.asr_provider)
self.asr_help = Gtk.Label(
xalign=0, wrap=True, label=selected_provider.credential_help)
self.asr_details.append(self.asr_help)
asr_actions = Gtk.Box(spacing=8, homogeneous=True)
self.asr_test_button = Gtk.Button(label=tr("Test API key", "测试 API Key"))
self.asr_test_button.connect("clicked", self._test_asr_clicked)
self.asr_clear_button = Gtk.Button(label=tr("Clear API key", "清除 API Key"))
self.asr_clear_button.connect("clicked", self._clear_asr_clicked)
asr_actions.append(self.asr_test_button)
asr_actions.append(self.asr_clear_button)
self.asr_details.append(asr_actions)
self.asr_status = Gtk.Label(xalign=0, wrap=True, selectable=True)
self.asr_status.add_css_class("accent")
self.asr_details.append(self.asr_status)
self.asr_details.set_visible(selected_provider.uses_api_key)
box.append(self.asr_details)
section(tr("Input", "输入"))
self.input_method = Gtk.DropDown.new_from_strings([
tr("Clipboard paste (default)", "剪贴板粘贴(默认)"),
tr("Direct typing", "直接输入"),
])
self.input_method.set_selected(INPUT_METHODS.index(settings.input_method))
row(tr("Text input method", "文字输入方式"), self.input_method)
self.direct_hint = Gtk.Label(xalign=0, wrap=True, label=tr(
"Direct typing keeps the clipboard unchanged and requires wtype and a compatible Wayland desktop (tested on Hyprland). Long text takes longer. Newlines and tabs act as Enter and Tab keys and may submit messages or move focus. Failure keeps your text without falling back to paste; some characters may already have been typed.",
"直接输入不会改动剪贴板,需要安装 wtype 并使用兼容的 Wayland 桌面(已在 Hyprland 验证)。长文本输入较慢;换行和制表符相当于回车和 Tab,可能发送消息或切换焦点。失败时保留文字,不自动转为粘贴;可能已有部分文字输入。"))
self.direct_hint.set_visible(settings.input_method == "direct")
box.append(self.direct_hint)
def use_key(key, modifiers=()):
if apply_key:
apply_key(key, modifiers)
else:
apply(replace(self._settings, doubao_key=key, doubao_modifiers=tuple(modifiers)))
self._settings = replace(self._settings, doubao_key=key,
doubao_modifiers=tuple(modifiers))
self.trigger_picker = TriggerPicker(settings.doubao_key, use_key, capture_key,
cancel_capture, modifiers=settings.doubao_modifiers)
box.append(self.trigger_picker)
self.enter = row(tr("Press the active trigger twice: send Enter",
"连续按两次当前触发键:发送回车"),
Gtk.Switch(active=settings.double_enter))
self.vibekey = row(tr("Enable Vibekey receiver buttons",
"启用 Vibekey 接收器按键"),
Gtk.Switch(active=settings.vibekey_enabled))
self.vibekey_details = Gtk.Box(
orientation=Gtk.Orientation.VERTICAL, spacing=10)
self.vibekey_details.set_margin_start(12)
self.vibekey_details.append(Gtk.Label(xalign=0, wrap=True, label=tr(
"Each Vibekey control keeps its built-in default below, or can send any recorded keyboard shortcut instead.",
"每个 Vibekey 控件都保留下方所示的默认功能,也可以改为发送任意录制的键盘快捷键。")))
box.append(self.vibekey_details)
def vibekey_picker(key_field, modifiers_field, title, default_label=None):
def use_shortcut(key, modifiers=()):
value = replace(self._settings, **{
key_field: key, modifiers_field: tuple(modifiers),
})
apply(value)
self._settings = value
picker = TriggerPicker(
getattr(settings, key_field), use_shortcut, capture_key,
cancel_capture, modifiers=getattr(settings, modifiers_field),
title=title, compact=True, default_label=default_label)
self.vibekey_details.append(picker)
return picker
self.vibekey_record = vibekey_picker(
"vibekey_record_key", "vibekey_record_modifiers",
tr("Record button", "录音按键"),
tr("Fn · Record dictation (default)", "Fn · 录音(默认)"))
self.vibekey_enter = vibekey_picker(
"vibekey_enter_key", "vibekey_enter_modifiers",
tr("Confirm button", "确认按键"),
tr("Enter · Confirm (default)", "Enter · 确认(默认)"))
self.vibekey_cancel = vibekey_picker(
"vibekey_cancel_key", "vibekey_cancel_modifiers",
tr("Cancel button", "取消按键"),
tr("Esc · Cancel (default)", "Esc · 取消(默认)"))
self.vibekey_clockwise = vibekey_picker(
"vibekey_clockwise_key", "vibekey_clockwise_modifiers",
tr("Turn right", "向右旋转"))
self.vibekey_counterclockwise = vibekey_picker(
"vibekey_counterclockwise_key", "vibekey_counterclockwise_modifiers",
tr("Turn left", "向左旋转"))
self.vibekey_press = vibekey_picker(
"vibekey_press_key", "vibekey_press_modifiers",
tr("Press dial", "按下旋钮"))
self.vibekey_pickers = (
self.vibekey_record, self.vibekey_enter, self.vibekey_cancel,
self.vibekey_clockwise, self.vibekey_counterclockwise,
self.vibekey_press)
self._sync_vibekey_details()
self.hold = Gtk.SpinButton.new_with_range(200, 1500, 50)
self.hold.set_value(settings.hold_ms)
self.double = Gtk.SpinButton.new_with_range(150, 600, 25)
self.double.set_value(settings.double_ms)
advanced = Gtk.Expander(label=tr("Advanced gesture timing", "高级手势时序"))
timing = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
for label, widget in [(tr("Hold threshold (ms)", "长按阈值(毫秒)"), self.hold),
(tr("Double-tap interval (ms)", "双击间隔(毫秒)"), self.double)]:
line = Gtk.Box(spacing=12)
line.append(Gtk.Label(label=label, xalign=0, hexpand=True))
line.append(widget)
timing.append(line)
advanced.set_child(timing)
box.append(advanced)
box.append(Gtk.Label(xalign=0, wrap=True, label=tr(
"Tap once to start or stop dictation. Hold to talk and release to finish. Pressing the active trigger twice sends Enter without dictation; it can submit a message or execute a terminal command. Test it in a plain text editor first.",
"短按一次开始或停止听写,长按说话、松开结束。连续按两次当前触发键会在不听写的情况下直接发送回车,可能发送消息或执行终端命令。请先在普通文本编辑器中测试。")))
section(tr("Appearance", "外观"))
self.waveform_style = Gtk.DropDown.new_from_strings([
tr("Classic bars", "经典声柱"), tr("Soft waves", "柔和声浪"),
tr("Concentric ripples", "同心涟漪"),
tr("Basketball rhythm", "篮球律动"),
])
self.waveform_style.set_selected(WAVEFORM_STYLES.index(settings.waveform_style))
row(tr("Listening waveform", "聆听波纹样式"), self.waveform_style)
self.motion = row(tr("Reduce waveform updates", "减少波形更新"),
Gtk.Switch(active=settings.reduced_motion))
button(tr("Preview appearance", "预览外观"), preview)
section(tr("Credentials & privacy", "凭证与隐私"))
self.privacy_copy = Gtk.Label(xalign=0, wrap=True)
box.append(self.privacy_copy)
self.login_button = button(tr("Open Doubao sign-in", "打开豆包登录"), login)
def confirm_sign_out():
dialog = Gtk.MessageDialog(transient_for=self.window, modal=True,
message_type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.OK_CANCEL,
text=tr("Clear saved recognition credentials?", "清除保存的语音识别凭证?"))
def response(win, choice):
win.destroy()
if choice == Gtk.ResponseType.OK:
try:
sign_out()
status.set_text(tr("Saved credentials cleared. Website sessions may remain.", "已清除保存的凭证,网站会话可能仍然存在。"))
except (ValueError, OSError) as error:
status.set_text(str(error))
dialog.connect("response", response)
dialog.present()
self.clear_credentials_button = button(
tr("Clear saved credentials…", "清除保存的凭证…"), confirm_sign_out)
section(tr("About & diagnostics", "关于与诊断"))
box.append(Gtk.Label(label=tr(
f"Doubao Say {VERSION} · Linux voice input",
f"豆包说 {VERSION} · Linux 语音输入"), xalign=0, wrap=True))
diagnostics = Gtk.TextView(editable=False, wrap_mode=Gtk.WrapMode.WORD_CHAR)
diagnostic_scroll = Gtk.ScrolledWindow(min_content_height=110, max_content_height=180)
diagnostic_scroll.set_child(diagnostics)
def refresh_diagnostics():
diagnostics.get_buffer().set_text(self._diagnostic_report())
button(tr("Preview diagnostic report", "预览诊断报告"), refresh_diagnostics)
box.append(diagnostic_scroll)
def copy_diagnostics():
refresh_diagnostics()
Gdk.Display.get_default().get_clipboard().set(self._diagnostic_report())
status.set_text(tr("Diagnostics copied. No transcripts, cookies or account IDs included.", "诊断已复制,不含转写文字、Cookie 或账号标识。"))
button(tr("Copy diagnostics", "复制诊断"), copy_diagnostics)
box.append(Gtk.Label(xalign=0, wrap=True, selectable=True, label=
"Based on wurong98/doubao-input-for-linux and lilong7676/doubao-murmur.\n"
+ tr("MIT notices retained; upstream distribution terms await clarification. See bundled LICENSE and NOTICE.",
"保留 MIT 版权说明;上游分发条款仍待澄清。详见安装目录中的 LICENSE 与 NOTICE。")))
footer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
for side in ("start", "end", "bottom"):
getattr(footer, "set_margin_" + side)(24)
footer.append(status)
root.append(footer)
self.language.connect("notify::selected", self._language_changed)
self.asr_provider.connect("notify::selected", self._asr_provider_changed)
self.asr_key.connect("changed", self._queue_asr_key_save)
self.autostart.connect("notify::active", self._changed)
self.input_method.connect("notify::selected", self._changed)
self.enter.connect("notify::active", self._changed)
self.vibekey.connect("notify::active", self._vibekey_changed)
self.hold.connect("value-changed", self._changed)
self.double.connect("value-changed", self._changed)
self.microphone.connect("notify::selected", self._changed)
self.waveform_style.connect("notify::selected", self._changed)
self.motion.connect("notify::active", self._changed)
self.window.connect("unmap", self._flush_asr_key)
self._sync_provider_details()
def _value(self):
return replace(self._settings,
language=LANGUAGES[self.language.get_selected()],
asr_provider=ASR_PROVIDERS[self.asr_provider.get_selected()],
doubao_key=self.trigger_picker.applied_key,
doubao_modifiers=self.trigger_picker.applied_modifiers,
hold_ms=self.hold.get_value_as_int(),
double_ms=self.double.get_value_as_int(),
double_enter=self.enter.get_active(),
vibekey_enabled=self.vibekey.get_active(),
vibekey_record_key=self.vibekey_record.applied_key,
vibekey_record_modifiers=self.vibekey_record.applied_modifiers,
vibekey_enter_key=self.vibekey_enter.applied_key,
vibekey_enter_modifiers=self.vibekey_enter.applied_modifiers,
vibekey_cancel_key=self.vibekey_cancel.applied_key,
vibekey_cancel_modifiers=self.vibekey_cancel.applied_modifiers,
vibekey_clockwise_key=self.vibekey_clockwise.applied_key,
vibekey_clockwise_modifiers=self.vibekey_clockwise.applied_modifiers,
vibekey_counterclockwise_key=self.vibekey_counterclockwise.applied_key,
vibekey_counterclockwise_modifiers=self.vibekey_counterclockwise.applied_modifiers,
vibekey_press_key=self.vibekey_press.applied_key,
vibekey_press_modifiers=self.vibekey_press.applied_modifiers,
input_method=INPUT_METHODS[self.input_method.get_selected()],
autostart=self.autostart.get_active(),
microphone=self.sources[self.microphone.get_selected()][0],
reduced_motion=self.motion.get_active(),
waveform_style=WAVEFORM_STYLES[self.waveform_style.get_selected()])
def _restore_controls(self):
self._updating = True
try:
self.language.set_selected(LANGUAGES.index(self._settings.language))
self.asr_provider.set_selected(ASR_PROVIDERS.index(self._settings.asr_provider))
self._sync_provider_details()
self.autostart.set_active(self._settings.autostart)
self.enter.set_active(self._settings.double_enter)
self.vibekey.set_active(self._settings.vibekey_enabled)
self.vibekey_record.sync(
self._settings.vibekey_record_key,
self._settings.vibekey_record_modifiers)
self.vibekey_enter.sync(
self._settings.vibekey_enter_key,
self._settings.vibekey_enter_modifiers)
self.vibekey_cancel.sync(
self._settings.vibekey_cancel_key,
self._settings.vibekey_cancel_modifiers)
self.vibekey_clockwise.sync(
self._settings.vibekey_clockwise_key,
self._settings.vibekey_clockwise_modifiers)
self.vibekey_counterclockwise.sync(
self._settings.vibekey_counterclockwise_key,
self._settings.vibekey_counterclockwise_modifiers)
self.vibekey_press.sync(
self._settings.vibekey_press_key,
self._settings.vibekey_press_modifiers)
self.input_method.set_selected(INPUT_METHODS.index(self._settings.input_method))
self.hold.set_value(self._settings.hold_ms)
self.double.set_value(self._settings.double_ms)
self.microphone.set_selected(
[key for key, _ in self.sources].index(self._settings.microphone))
self.motion.set_active(self._settings.reduced_motion)
self.waveform_style.set_selected(WAVEFORM_STYLES.index(self._settings.waveform_style))
finally:
self._updating = False
self._sync_vibekey_details()
def _save_current(self):
if self._updating:
return True
if any(picker.listening for picker in
(self.trigger_picker, *self.vibekey_pickers)):
self.status.set_text(tr("Finish or cancel key capture first.",
"请先结束或取消按键录制。"))
return False
value = self._value()
if value == self._settings:
return True
try:
self._apply(value)
except (ValueError, OSError) as error:
self._restore_controls()
self.status.set_text(str(error))
return False
self._settings = value
self.status.set_text(tr("Saved automatically.", "已自动保存。"))
return True
def _changed(self, *_):
self._save_current()
self.direct_hint.set_visible(self._settings.input_method == "direct")
def _sync_vibekey_details(self):
self.vibekey_details.set_visible(self.vibekey.get_active())
def _vibekey_changed(self, *_):
if self._updating:
self._sync_vibekey_details()
return
if not self._save_current():
self._updating = True
try:
self.vibekey.set_active(self._settings.vibekey_enabled)
finally:
self._updating = False
self._sync_vibekey_details()
def _refresh_microphones(self, *, announce=False):
discovered = microphones()
sources = [("", tr("System default", "系统默认"))] + discovered
selected = self._settings.microphone
if selected and selected not in [key for key, _ in sources]:
sources.append((selected, tr(
"Saved device (unavailable)", "已保存设备(当前不可用)")))
was_updating = self._updating
self._updating = True
try:
self.sources = sources
self.microphone.set_model(Gtk.StringList.new(
[label for _, label in sources]))
self.microphone.set_selected(
[key for key, _ in sources].index(selected))
finally:
self._updating = was_updating
if announce:
count = len(discovered)
self.status.set_text(tr(
f"Microphone devices refreshed: {count} found.",
f"已刷新麦克风设备:找到 {count} 个。"))
def _language_changed(self, *_):
previous = self._settings.language
if not self._save_current() or self._settings.language == previous:
return
try:
self._restart()
except (ValueError, OSError) as error:
self.status.set_text(str(error))
def _asr_provider_changed(self, *_):
if self._updating:
return
if self._asr_testing:
self._restore_controls()
return
# The application still owns the previous provider until _save_current.
# Flush its draft before changing the credential store used by callbacks.
if not self.flush_edits():
self._restore_controls()
return
self._sync_provider_details()
if not self._save_current():
return
provider = recognition_provider(
ASR_PROVIDERS[self.asr_provider.get_selected()])
self._asr_has_key = self._asr_has_key_func()
self.asr_key.set_placeholder_text(tr(
"Saved — leave blank to keep" if self._asr_has_key else "Enter speech API key",
"已保存,留空则保持不变" if self._asr_has_key else "填写语音 API Key"))
self.asr_status.set_text(tr(
"Enter an API key before using this recognition service.",
"使用当前语音识别服务前请填写 API Key。")
if provider.uses_api_key and not self._asr_has_key else "")
def _sync_provider_details(self):
provider = recognition_provider(
ASR_PROVIDERS[self.asr_provider.get_selected()])
self.asr_details.set_visible(provider.uses_api_key)
self.login_button.set_visible(provider.interactive_auth)
self.clear_credentials_button.set_visible(provider.interactive_auth)
self.asr_help.set_text(provider.credential_help)
self.privacy_copy.set_text(provider.privacy)
def _queue_asr_key_save(self, *_):
if self._updating or not self.asr_key.get_text().strip():
return
if self._asr_save_source:
GLib.source_remove(self._asr_save_source)
self._asr_save_source = GLib.timeout_add(500, self._run_asr_key_save)
def _run_asr_key_save(self):
self._asr_save_source = 0
self._save_asr_key_now()
return GLib.SOURCE_REMOVE
def _save_asr_key_now(self):
key = self.asr_key.get_text().strip()
if not key:
return True
try:
self._save_asr(key)
except (ValueError, OSError) as error:
self.asr_status.set_text(str(error))
self.status.set_text(tr(
"API key could not be saved. Try again.", "API Key 保存失败,请重试。"))
return False
self._asr_has_key = True
self._updating = True
try:
self.asr_key.set_text("")
self.asr_key.set_placeholder_text(tr(
"Saved — leave blank to keep", "已保存,留空则保持不变"))
finally:
self._updating = False
self.asr_status.set_text(tr("API key saved automatically.", "API Key 已自动保存。"))
self.status.set_text(tr("API key saved automatically.", "API Key 已自动保存。"))
return True
def flush_edits(self):
if self._asr_save_source:
GLib.source_remove(self._asr_save_source)
self._asr_save_source = 0
return self._save_asr_key_now()
def _flush_asr_key(self, *_):
return self.flush_edits()
def _clear_asr_clicked(self, *_):
try:
self._clear_asr()
except (ValueError, OSError) as error:
self.asr_status.set_text(str(error))
return
self._asr_has_key = False
self._updating = True
try:
self.asr_key.set_text("")
self.asr_key.set_placeholder_text(tr(
"Enter speech API key", "填写语音 API Key"))
finally:
self._updating = False
self.asr_status.set_text(tr("API key cleared.", "API Key 已清除。"))
self.status.set_text(tr("API key cleared.", "API Key 已清除。"))
def _test_asr_clicked(self, *_):
if self._asr_testing:
return
if not self.flush_edits():
return
if not (self._asr_has_key or self.asr_key.get_text().strip()):
self.asr_status.set_text(tr("Enter an API key first.", "请先填写 API Key。"))
return
self._asr_testing = True
self.asr_provider.set_sensitive(False)
self.asr_test_button.set_sensitive(False)
self.asr_test_button.set_label(tr("Testing…", "正在测试…"))
self.asr_status.set_text(tr(
"Testing speech recognition…", "正在测试语音识别…"))
try:
self._test_asr(self.asr_key.get_text().strip() or None, self._asr_tested)
except (ValueError, OSError) as error:
self._asr_tested(None, str(error))
def _asr_tested(self, result, error):
self._asr_testing = False
self.asr_provider.set_sensitive(True)
self.asr_test_button.set_sensitive(True)
self.asr_test_button.set_label(tr("Test API key", "测试 API Key"))
self.asr_status.set_text((tr("Test failed: ", "测试失败:") + error)
if error else (result or tr(
"API key accepted.", "API Key 可用。")))
def _close(self, *_):
for picker in (self.trigger_picker, *self.vibekey_pickers):
picker.cancel()
flush = getattr(self, "_flush_asr_key", None)
if flush and not flush():
return True
return not self._save_current()
def show(self):
self._refresh_microphones()
self.window.present()