From 00a44e123f51a4a7557556dfa24c7febc58c85b0 Mon Sep 17 00:00:00 2001 From: vicrodh <103399283+vicrodh@users.noreply.github.com> Date: Tue, 7 Jul 2026 17:37:30 -0600 Subject: [PATCH] =?UTF-8?q?feat(qconnect):=20startup=20behavior=20setting?= =?UTF-8?q?=20=E2=80=94=20remember=20state=20/=20on=20/=20off?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Restores the Tauri-era Qobuz Connect startup setting, now in Settings > Playback per owner request. Reuses the shared qconnect-app::startup module (QconnectStartupMode + compute_effective_startup, unit-tested) and Tauri's exact qconnect_settings.db keys (startup_mode / last_known_state), so an upgrading user's choice survives. last_known_state is written at the manual toggle's success points only — internal teardowns (D5 offline force-disconnect, bootstrap failure cleanup) never clobber the remembered state, mirroring Tauri's command layer. Startup auto-connect runs post-enter_shell (online sessions only, once per process) through the same connect() path as the toggle, on Tauri's bounded retry schedule, bailing silently under offline mode instead of toasting per retry. Select row mirrors the quality-retries row; 5 msgids x8 locales. cc --- .../translations/de/LC_MESSAGES/qbz-ui.po | 12 +++ .../translations/en/LC_MESSAGES/qbz-ui.po | 12 +++ .../translations/es/LC_MESSAGES/qbz-ui.po | 12 +++ .../translations/fr/LC_MESSAGES/qbz-ui.po | 12 +++ .../translations/ja/LC_MESSAGES/qbz-ui.po | 12 +++ .../translations/nl/LC_MESSAGES/qbz-ui.po | 12 +++ .../translations/pt/LC_MESSAGES/qbz-ui.po | 12 +++ .../translations/ru/LC_MESSAGES/qbz-ui.po | 12 +++ .../qbz-ui/ui/settings/PlaybackSettings.slint | 13 +++ crates/qbz-ui/ui/state.slint | 6 ++ crates/qbz/src/main.rs | 34 ++++++- crates/qbz/src/qconnect_service.rs | 93 +++++++++++++++++++ crates/qbz/src/qconnect_transport.rs | 83 +++++++++++++++++ crates/qbz/src/settings.rs | 45 +++++++++ 14 files changed, 366 insertions(+), 4 deletions(-) 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}"), } }