diff --git a/crates/qbz-ui/translations/de/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/de/LC_MESSAGES/qbz-ui.po index 08236e76c..07b4bf428 100644 --- a/crates/qbz-ui/translations/de/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/de/LC_MESSAGES/qbz-ui.po @@ -4464,3 +4464,15 @@ msgstr "QBZ kann ohne Qobuz™-Konto als Offline-Player genutzt werden (kein Zug # Renderer degradation ladder toast (generic: GL or software rung) msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "Renderer automatisch gewechselt — der vorherige konnte nicht starten" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "Qobuz Connect beim Start automatisch verbinden" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "Wählen, ob Qobuz Connect beim Start von QBZ automatisch aktiviert wird." +msgid "Remember state" +msgstr "Zustand merken" +msgid "On by default" +msgstr "Standardmäßig ein" +msgid "Off by default" +msgstr "Standardmäßig aus" diff --git a/crates/qbz-ui/translations/en/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/en/LC_MESSAGES/qbz-ui.po index a4bae9ff2..ba8a6ad33 100644 --- a/crates/qbz-ui/translations/en/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/en/LC_MESSAGES/qbz-ui.po @@ -233,3 +233,15 @@ msgstr "QBZ can be used as an offline player without a Qobuz™ account (no acce # Renderer degradation ladder toast (generic: GL or software rung) msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "Renderer switched automatically — the previous renderer failed to start" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "Auto-connect Qobuz Connect on startup" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgid "Remember state" +msgstr "Remember state" +msgid "On by default" +msgstr "On by default" +msgid "Off by default" +msgstr "Off by default" diff --git a/crates/qbz-ui/translations/es/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/es/LC_MESSAGES/qbz-ui.po index 57cb85900..22cee93a3 100644 --- a/crates/qbz-ui/translations/es/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/es/LC_MESSAGES/qbz-ui.po @@ -4494,3 +4494,15 @@ msgstr "QBZ puede usarse como reproductor sin conexión sin una cuenta de Qobuz # Renderer degradation ladder toast (generic: GL or software rung) msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "El renderizador cambió automáticamente — el anterior no pudo iniciar" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "Conectar Qobuz Connect automáticamente al iniciar" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "Elige si Qobuz Connect se activa automáticamente cuando QBZ inicia." +msgid "Remember state" +msgstr "Recordar estado" +msgid "On by default" +msgstr "Activado de forma predeterminada" +msgid "Off by default" +msgstr "Desactivado de forma predeterminada" diff --git a/crates/qbz-ui/translations/fr/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/fr/LC_MESSAGES/qbz-ui.po index d2296625b..4c27d0e6c 100644 --- a/crates/qbz-ui/translations/fr/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/fr/LC_MESSAGES/qbz-ui.po @@ -4464,3 +4464,15 @@ msgstr "QBZ peut être utilisé comme lecteur hors ligne sans compte Qobuz™ (p # Renderer degradation ladder toast (generic: GL or software rung) msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "Moteur de rendu changé automatiquement — le précédent n'a pas pu démarrer" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "Connecter Qobuz Connect automatiquement au démarrage" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "Choisir si Qobuz Connect s'active automatiquement au lancement de QBZ." +msgid "Remember state" +msgstr "Mémoriser l'état" +msgid "On by default" +msgstr "Activé par défaut" +msgid "Off by default" +msgstr "Désactivé par défaut" diff --git a/crates/qbz-ui/translations/ja/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/ja/LC_MESSAGES/qbz-ui.po index 6d9442177..100562507 100644 --- a/crates/qbz-ui/translations/ja/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/ja/LC_MESSAGES/qbz-ui.po @@ -4453,3 +4453,15 @@ msgstr "QBZはQobuz™アカウントなしでオフラインプレーヤーと # Renderer degradation ladder toast (generic: GL or software rung) msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "レンダラーを自動的に切り替えました — 前のレンダラーは起動できませんでした" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "起動時にQobuz Connectを自動接続" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "QBZの起動時にQobuz Connectを自動的に有効にするかを選択します。" +msgid "Remember state" +msgstr "状態を記憶" +msgid "On by default" +msgstr "デフォルトでオン" +msgid "Off by default" +msgstr "デフォルトでオフ" diff --git a/crates/qbz-ui/translations/nl/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/nl/LC_MESSAGES/qbz-ui.po index 1c8336c2e..87c76d395 100644 --- a/crates/qbz-ui/translations/nl/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/nl/LC_MESSAGES/qbz-ui.po @@ -4476,3 +4476,15 @@ msgstr "QBZ kan worden gebruikt als offline speler zonder Qobuz™-account (geen msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "Renderer automatisch overgeschakeld — de vorige renderer kon niet starten" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "Qobuz Connect automatisch verbinden bij opstarten" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "Kies of Qobuz Connect automatisch wordt geactiveerd wanneer QBZ start." +msgid "Remember state" +msgstr "Status onthouden" +msgid "On by default" +msgstr "Standaard aan" +msgid "Off by default" +msgstr "Standaard uit" diff --git a/crates/qbz-ui/translations/pt/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/pt/LC_MESSAGES/qbz-ui.po index d04b5f536..3f1fa463b 100644 --- a/crates/qbz-ui/translations/pt/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/pt/LC_MESSAGES/qbz-ui.po @@ -4464,3 +4464,15 @@ msgstr "O QBZ pode ser usado como reprodutor offline sem conta Qobuz™ (sem ace # Renderer degradation ladder toast (generic: GL or software rung) msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "Renderizador alterado automaticamente — o anterior não pôde iniciar" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "Ligar o Qobuz Connect automaticamente ao iniciar" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "Escolha se o Qobuz Connect é ativado automaticamente quando o QBZ inicia." +msgid "Remember state" +msgstr "Lembrar estado" +msgid "On by default" +msgstr "Ligado por padrão" +msgid "Off by default" +msgstr "Desligado por padrão" diff --git a/crates/qbz-ui/translations/ru/LC_MESSAGES/qbz-ui.po b/crates/qbz-ui/translations/ru/LC_MESSAGES/qbz-ui.po index b2d5f5788..731c4fd6b 100644 --- a/crates/qbz-ui/translations/ru/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-ui/translations/ru/LC_MESSAGES/qbz-ui.po @@ -4477,3 +4477,15 @@ msgstr "QBZ можно использовать как офлайн-плеер # Renderer degradation ladder toast (generic: GL or software rung) msgid "Renderer switched automatically — the previous renderer failed to start" msgstr "Рендерер переключён автоматически — предыдущий не смог запуститься" + +# QConnect startup behavior (Settings > Playback, ported from Tauri) +msgid "Auto-connect Qobuz Connect on startup" +msgstr "Автоматически подключать Qobuz Connect при запуске" +msgid "Choose whether Qobuz Connect activates automatically when QBZ launches." +msgstr "Выберите, включается ли Qobuz Connect автоматически при запуске QBZ." +msgid "Remember state" +msgstr "Запоминать состояние" +msgid "On by default" +msgstr "Включено по умолчанию" +msgid "Off by default" +msgstr "Выключено по умолчанию" diff --git a/crates/qbz-ui/ui/settings/PlaybackSettings.slint b/crates/qbz-ui/ui/settings/PlaybackSettings.slint index 56b8c050d..48f1a64a5 100644 --- a/crates/qbz-ui/ui/settings/PlaybackSettings.slint +++ b/crates/qbz-ui/ui/settings/PlaybackSettings.slint @@ -99,6 +99,19 @@ export component PlaybackSettings inherits VerticalLayout { } } } + SettingRow { + label: @tr("Auto-connect Qobuz Connect on startup"); + description: @tr("Choose whether Qobuz Connect activates automatically when QBZ launches."); + QbzSelect { + menu-width: 240px; + options: SettingsState.qconnect-startup-modes; + current-index: SettingsState.qconnect-startup-index; + selected(i) => { + SettingsState.qconnect-startup-index = i; + root.settings-select("qconnect-startup", i); + } + } + } Rectangle { height: 12px; } Divider { } diff --git a/crates/qbz-ui/ui/state.slint b/crates/qbz-ui/ui/state.slint index 5d9c4bfe6..dc4145780 100644 --- a/crates/qbz-ui/ui/state.slint +++ b/crates/qbz-ui/ui/state.slint @@ -2865,6 +2865,12 @@ export global SettingsState { in-out property <[string]> retry-behaviors: []; in-out property retry-behavior-index: 0; + // Playback — "Auto-connect Qobuz Connect on startup" dropdown + // (remember-last / on / off). Backed by the QConnect settings DB via the + // Rust controller, which owns the index -> mode mapping. + in-out property <[string]> qconnect-startup-modes: []; + in-out property qconnect-startup-index: 0; + // --- OFFLINE MODE -------------------------------------------------------- // Settings > Offline, MODE group (the app operating without Qobuz — NOT diff --git a/crates/qbz/src/main.rs b/crates/qbz/src/main.rs index e64ed617e..ed2a0efe1 100644 --- a/crates/qbz/src/main.rs +++ b/crates/qbz/src/main.rs @@ -420,6 +420,13 @@ async fn enter_shell( // background — store reads and device enumeration are blocking. spawn_settings_snapshot_load(runtime.clone(), weak.clone(), settings_ctx.clone()); + // Qobuz Connect startup auto-connect (Settings > Playback): "On by + // default", or "Remember state" + last session ended connected, drives the + // SAME connect path as the bar toggle. Online shell entries only — the + // offline entry (`enter_shell_offline`) never auto-connects, and connect() + // itself refuses offline / uninitialized sessions. Fires once per process. + qconnect_service::spawn_startup_auto_connect(&tokio::runtime::Handle::current()); + // Load the genre-filter parents + persisted selection, then seed // the popup state. Done before the discover load so the first // fetch honors a remembered genre selection. @@ -11265,20 +11272,39 @@ fn main() -> Result<(), Box> { }; let weak = weak.clone(); handle.spawn(async move { - let connected = if svc.is_running().await { + // `record`: the "Remember state" write-through value — Some + // only when the operation SUCCEEDED (Tauri v2_qconnect_connect + // / _disconnect wrote nothing on failure, so a failed manual + // connect never downgrades a remembered "connected"). + let (connected, record) = if svc.is_running().await { if let Err(err) = svc.disconnect().await { log::warn!("[QConnect] disconnect failed: {err}"); } - false + (false, Some(false)) } else { match svc.connect().await { - Ok(()) => true, + Ok(()) => (true, Some(true)), Err(err) => { log::warn!("[QConnect] connect failed: {err}"); - false + (false, None) } } }; + // Record the USER-chosen on/off here — the authoritative + // intent point (the bar toggle, the only manual path) — so a + // crash can't lose it and internal teardowns (offline + // force-disconnect, bootstrap cleanup) never overwrite it. + // Only while mode == RememberLast, mirroring Tauri. + if let Some(state) = record { + let _ = tokio::task::spawn_blocking(move || { + if qconnect_transport::load_startup_mode() + == qconnect_app::QconnectStartupMode::RememberLast + { + qconnect_transport::save_last_known_state(state); + } + }) + .await; + } let _ = weak.upgrade_in_event_loop(move |w| { w.global::() .set_qconnect_connected(connected); diff --git a/crates/qbz/src/qconnect_service.rs b/crates/qbz/src/qconnect_service.rs index 0a4e5676d..9c8ed4200 100644 --- a/crates/qbz/src/qconnect_service.rs +++ b/crates/qbz/src/qconnect_service.rs @@ -110,6 +110,99 @@ pub fn service() -> Option> { SERVICE.get().cloned() } +/// Startup auto-connect (Settings > Playback, "Auto-connect Qobuz Connect on +/// startup"). Ports the Tauri `startup.rs::maybe_auto_connect_after_bootstrap` +/// + its bounded retry schedule (gap #8): decide from the persisted mode (and, +/// for RememberLast, the last-known connect state), then drive the SAME +/// `connect()` path as the bar toggle — no duplicated connection logic. +/// +/// Called from `enter_shell` AFTER session activation, online sessions only +/// (the offline shell entry never calls this); `connect()` itself additionally +/// refuses an uninitialized API and offline mode (D5). Fires at most once per +/// process, so a logout/login cycle does not re-trigger it. +pub fn spawn_startup_auto_connect(handle: &tokio::runtime::Handle) { + use std::sync::atomic::{AtomicBool, Ordering}; + static FIRED: AtomicBool = AtomicBool::new(false); + if FIRED.swap(true, Ordering::SeqCst) { + return; + } + handle.spawn(async move { + // Blocking SQLite reads — cheap, but keep them off the caller's path. + let mode = crate::qconnect_transport::load_startup_mode(); + let last = crate::qconnect_transport::load_last_known_state(); + let should_connect = qconnect_app::compute_effective_startup(mode, None, last); + log::info!( + "[QConnect] startup auto-connect decision: mode={} last_known={:?} -> {}", + mode.as_str(), + last, + should_connect + ); + if !should_connect { + return; + } + // The service singleton is initialized during main() wiring, which runs + // concurrently with the session-restore task that enters the shell — + // wait for it briefly instead of racing (it lands within milliseconds). + let service = { + let mut waited_ms = 0u64; + loop { + if let Some(svc) = service() { + break svc; + } + if waited_ms >= 5_000 { + log::warn!("[QConnect] startup auto-connect: service never initialized"); + return; + } + tokio::time::sleep(std::time::Duration::from_millis(100)).await; + waited_ms += 100; + } + }; + // Tauri's `startup_retry_schedule()` (gap #8): one immediate attempt, + // then one per scheduled delay; give up for the session after the last + // step. Each connect() re-resolves the transport config internally, so + // a transient credential/network failure can clear on a later attempt. + let schedule: [u64; 4] = [2_000, 5_000, 15_000, 30_000]; + for attempt in 0..=schedule.len() { + // D5: offline (incl. persisted induced-offline surviving a + // restart) — bail silently instead of letting connect()'s + // offline refusal TOAST on every retry (5 spams over ~52s). + if crate::offline_mode::engine().is_offline() { + log::info!("[QConnect] startup auto-connect skipped: offline mode active (D5)"); + return; + } + match service.connect().await { + Ok(()) => { + log::info!("[QConnect] startup auto-connect succeeded"); + // Mirror the manual toggle's tail: flip the bar badge on. + let _ = service.window.upgrade_in_event_loop(|w| { + use slint::ComponentHandle; + w.global::().set_qconnect_connected(true); + }); + return; + } + Err(err) => { + log::warn!( + "[QConnect] startup auto-connect attempt {} failed: {err}", + attempt + 1 + ); + } + } + match schedule.get(attempt) { + Some(delay_ms) => { + tokio::time::sleep(std::time::Duration::from_millis(*delay_ms)).await; + } + None => { + log::warn!( + "[QConnect] startup auto-connect gave up for this session after {} attempts", + attempt + 1 + ); + return; + } + } + } + }); +} + // ---- DEV diagnostics (QconnectDevModal) ------------------------------------ // A rolling, runtime-inspectable event log + live status block, so QConnect can // be debugged WITHOUT a rebuild (Slint builds are slow). Populated by the event diff --git a/crates/qbz/src/qconnect_transport.rs b/crates/qbz/src/qconnect_transport.rs index 6feb04a04..5bcaf27bd 100644 --- a/crates/qbz/src/qconnect_transport.rs +++ b/crates/qbz/src/qconnect_transport.rs @@ -327,6 +327,89 @@ pub fn persist_device_name(name: Option<&str>) { } } +/// Open the QConnect settings DB (key/value table), creating it when missing. +/// Fail-open helper for the startup-mode persistence below — mirrors the Tauri +/// `startup.rs::open_settings_conn`. +fn open_qconnect_settings_conn() -> Option { + let db_path = qconnect_settings_db_path()?; + let conn = rusqlite::Connection::open(&db_path).ok()?; + conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;") + .ok()?; + conn.execute_batch( + "CREATE TABLE IF NOT EXISTS settings ( + key TEXT PRIMARY KEY, + value TEXT NOT NULL + )", + ) + .ok()?; + Some(conn) +} + +/// Load the persisted QConnect startup mode (Settings > Playback, +/// "Auto-connect Qobuz Connect on startup"). Same DB + key + values as the +/// Tauri app (`startup_mode` = "off" | "on" | "remember_last" in +/// `qconnect_settings.db`), so an existing setting survives the Tauri -> Slint +/// migration. Fail-open: returns `Off` (the default) when missing or invalid. +pub fn load_startup_mode() -> qconnect_app::QconnectStartupMode { + let Some(conn) = open_qconnect_settings_conn() else { + return qconnect_app::QconnectStartupMode::default(); + }; + conn.query_row( + "SELECT value FROM settings WHERE key = 'startup_mode'", + [], + |row| row.get::<_, String>(0), + ) + .ok() + .as_deref() + .and_then(qconnect_app::QconnectStartupMode::from_str) + .unwrap_or_default() +} + +/// Persist the QConnect startup mode. +pub fn save_startup_mode(mode: qconnect_app::QconnectStartupMode) { + let Some(conn) = open_qconnect_settings_conn() else { + return; + }; + let _ = conn.execute( + "INSERT OR REPLACE INTO settings (key, value) VALUES ('startup_mode', ?1)", + rusqlite::params![mode.as_str()], + ); +} + +/// Load the last-known QConnect on/off state, if recorded. Same key/values as +/// Tauri (`last_known_state` = "on" | "off"). +pub fn load_last_known_state() -> Option { + let conn = open_qconnect_settings_conn()?; + let value: Option = conn + .query_row( + "SELECT value FROM settings WHERE key = 'last_known_state'", + [], + |row| row.get::<_, String>(0), + ) + .ok(); + match value.as_deref() { + Some("on") => Some(true), + Some("off") => Some(false), + _ => None, + } +} + +/// Persist the last-known on/off state. Written from the USER-facing +/// connect/disconnect path (the bar toggle) when `startup_mode == +/// RememberLast` — never from internal teardowns (offline force-disconnect, +/// bootstrap-failure cleanup), mirroring Tauri's command-layer write-through: +/// a transient failure must not clobber a remembered "connected". +pub fn save_last_known_state(state: bool) { + let Some(conn) = open_qconnect_settings_conn() else { + return; + }; + let value = if state { "on" } else { "off" }; + let _ = conn.execute( + "INSERT OR REPLACE INTO settings (key, value) VALUES ('last_known_state', ?1)", + rusqlite::params![value], + ); +} + /// Build the WS transport config: env overrides first, then auto-discovery via /// `qws/createToken`. Mirrors the Tauri `resolve_transport_config` (the /// per-option knobs are deferred — the Slint connect path uses defaults + diff --git a/crates/qbz/src/settings.rs b/crates/qbz/src/settings.rs index 63889e089..8d368e3f7 100644 --- a/crates/qbz/src/settings.rs +++ b/crates/qbz/src/settings.rs @@ -24,6 +24,7 @@ use qbz_app::settings::playback::{ use qbz_app::shell::AppRuntime; use qbz_audio::backend::{AlsaPlugin, AudioBackendType, BackendManager}; use qbz_audio::settings::{AudioSettingsState, AudioSettingsStore}; +use qconnect_app::QconnectStartupMode; use slint::{ComponentHandle, ModelRc, SharedString, VecModel}; use crate::adapter::SlintAdapter; @@ -69,6 +70,19 @@ const RETRY_BEHAVIORS: &[(&str, &str)] = &[ (qbz_i18n::mark("Always skip track"), "always_skip"), ]; +/// "Auto-connect Qobuz Connect on startup" dropdown options. The value is the +/// persisted QConnect startup mode — same DB key + values as the Tauri app +/// (`startup_mode` in `qconnect_settings.db`), persisted via +/// `crate::qconnect_transport`, NOT the audio/playback stores. +const QCONNECT_STARTUP_MODES: &[(&str, QconnectStartupMode)] = &[ + ( + qbz_i18n::mark("Remember state"), + QconnectStartupMode::RememberLast, + ), + (qbz_i18n::mark("On by default"), QconnectStartupMode::On), + (qbz_i18n::mark("Off by default"), QconnectStartupMode::Off), +]; + /// What a persisted audio change requires of the live `Player`. enum Apply { /// Not a player-applied setting — nothing to apply. @@ -171,6 +185,8 @@ pub struct SettingsSnapshot { buffer_seconds: i32, retry_behaviors: Vec, retry_behavior_index: i32, + qconnect_startup_modes: Vec, + qconnect_startup_index: i32, // Now-playing output indicators (backend + effective bit-perfect mode). output_backend_label: String, output_mode_label: String, @@ -489,6 +505,13 @@ fn build_snapshot( .iter() .position(|(_, v)| *v == audio.quality_fallback_behavior) .unwrap_or(0); + // QConnect startup mode — read from the QConnect settings DB (blocking + // SQLite, fine here: build_snapshot always runs inside spawn_blocking). + let qconnect_startup_mode = crate::qconnect_transport::load_startup_mode(); + let qconnect_startup_index = QCONNECT_STARTUP_MODES + .iter() + .position(|(_, m)| *m == qconnect_startup_mode) + .unwrap_or(QCONNECT_STARTUP_MODES.len() - 1); // last entry = Off (default) let backend_is_alsa = active_backend == AudioBackendType::Alsa; let backend_is_pipewire = active_backend == AudioBackendType::PipeWire; @@ -555,6 +578,11 @@ fn build_snapshot( buffer_seconds: audio.stream_buffer_seconds as i32, retry_behaviors: RETRY_BEHAVIORS.iter().map(|(l, _)| qbz_i18n::t(l)).collect(), retry_behavior_index: retry_behavior_index as i32, + qconnect_startup_modes: QCONNECT_STARTUP_MODES + .iter() + .map(|(l, _)| qbz_i18n::t(l)) + .collect(), + qconnect_startup_index: qconnect_startup_index as i32, output_backend_label: out_backend_label, output_mode_label: out_mode_label, output_backend_active: out_backend_active, @@ -643,6 +671,8 @@ pub fn apply_snapshot(window: &AppWindow, snap: SettingsSnapshot) { st.set_buffer_seconds(snap.buffer_seconds); st.set_retry_behaviors(string_model(snap.retry_behaviors)); st.set_retry_behavior_index(snap.retry_behavior_index); + st.set_qconnect_startup_modes(string_model(snap.qconnect_startup_modes)); + st.set_qconnect_startup_index(snap.qconnect_startup_index); st.set_loading(false); } @@ -1191,6 +1221,21 @@ pub async fn handle_select( } apply_audio(&ctx, &runtime, Apply::Reload); } + "qconnect-startup" => { + // Persisted in the QConnect settings DB (same key/values as the + // Tauri app) — nothing to apply to the live player: the mode is + // only consulted at startup (and by the toggle's write-through). + let Some((_, mode)) = QCONNECT_STARTUP_MODES.get(index) else { + return; + }; + let mode = *mode; + if let Err(e) = + tokio::task::spawn_blocking(move || crate::qconnect_transport::save_startup_mode(mode)) + .await + { + log::error!("[qbz-slint] persist qconnect startup mode failed: {e}"); + } + } other => log::warn!("[qbz-slint] unknown settings select key: {other}"), } }