//! V2 Commands - Using the new multi-crate architecture //! //! These commands use QbzCore via CoreBridge instead of the old AppState. //! Runtime contract ensures proper lifecycle (see ADR_RUNTIME_SESSION_CONTRACT.md). //! //! Playback flows through CoreBridge -> QbzCore -> Player (qbz-player crate). use std::sync::Arc; use tauri::{Emitter, State}; use tokio::sync::RwLock; use qbz_models::{Album, Artist, Playlist, Quality, QueueState, RepeatMode, SearchResultsPage, Track, UserSession}; use crate::artist_blacklist::BlacklistState; use crate::cache::AudioCache; use crate::audio::{AlsaPlugin, AudioBackendType}; use crate::config::audio_settings::{AudioSettings, AudioSettingsState}; use crate::core_bridge::CoreBridgeState; use crate::offline_cache::OfflineCacheState; use crate::queue::QueueManager; use crate::runtime::{RuntimeManagerState, RuntimeStatus, RuntimeError, RuntimeEvent, RuntimeState, DegradedReason}; use crate::AppState; // ==================== Helper Functions ==================== /// Convert quality string from frontend to Quality enum fn parse_quality(quality_str: Option<&str>) -> Quality { match quality_str { Some("MP3") => Quality::Mp3, Some("CD Quality") => Quality::Lossless, Some("Hi-Res") => Quality::HiRes, Some("Hi-Res+") => Quality::UltraHiRes, _ => Quality::UltraHiRes, // Default to highest } } /// Limit quality based on device's max sample rate fn limit_quality_for_device(quality: Quality, max_sample_rate: Option) -> Quality { let Some(max_rate) = max_sample_rate else { return quality; }; if max_rate <= 48000 { match quality { Quality::UltraHiRes | Quality::HiRes => { log::info!( "[V2/Quality Limit] Device max {}Hz, limiting {} to Lossless (44.1kHz)", max_rate, quality.label() ); Quality::Lossless } _ => quality, } } else if max_rate <= 96000 { match quality { Quality::UltraHiRes => { log::info!( "[V2/Quality Limit] Device max {}Hz, limiting Hi-Res+ to Hi-Res (96kHz)", max_rate ); Quality::HiRes } _ => quality, } } else { quality } } /// Download audio from URL async fn download_audio(url: &str) -> Result, String> { use std::time::Duration; let client = reqwest::Client::builder() .timeout(Duration::from_secs(120)) .connect_timeout(Duration::from_secs(10)) .build() .map_err(|e| format!("Failed to create HTTP client: {}", e))?; log::info!("[V2] Downloading audio..."); let response = client .get(url) .header("User-Agent", "Mozilla/5.0") .send() .await .map_err(|e| format!("Failed to fetch audio: {}", e))?; if !response.status().is_success() { return Err(format!("HTTP error: {}", response.status())); } let bytes = response .bytes() .await .map_err(|e| format!("Failed to read audio bytes: {}", e))?; log::info!("[V2] Downloaded {} bytes", bytes.len()); Ok(bytes.to_vec()) } // ==================== Runtime Contract Commands ==================== /// Get current runtime status /// Use this to check if the runtime is ready before calling other commands #[tauri::command] pub async fn runtime_get_status( runtime: State<'_, RuntimeManagerState>, ) -> Result { Ok(runtime.manager().get_status().await) } /// Bootstrap the runtime - single entrypoint for initialization /// /// This command: /// 1. Initializes the API client (extracts bundle tokens) /// 2. Checks for saved credentials and auto-logs in if available /// 3. Activates per-user session if user is logged in /// 4. Authenticates CoreBridge/V2 /// /// Returns RuntimeStatus with full state information. /// Clients should call this once at startup and react to the returned state. #[tauri::command] pub async fn runtime_bootstrap( app: tauri::AppHandle, runtime: State<'_, RuntimeManagerState>, app_state: State<'_, AppState>, core_bridge: State<'_, CoreBridgeState>, ) -> Result { let manager = runtime.manager(); // Check if bootstrap is already in progress if manager.is_bootstrap_in_progress().await { return Err(RuntimeError::BootstrapInProgress); } manager.set_bootstrap_in_progress(true).await; log::info!("[Runtime] Bootstrap starting..."); // Step 1: Initialize API client (bundle tokens) { let client = app_state.client.read().await; match client.init().await { Ok(_) => { log::info!("[Runtime] API client initialized (bundle tokens extracted)"); manager.set_client_initialized(true).await; let _ = app.emit("runtime:event", RuntimeEvent::RuntimeInitialized); } Err(e) => { let reason = DegradedReason::BundleExtractionFailed(e.to_string()); log::error!("[Runtime] Bundle extraction failed: {}", e); manager.set_degraded(reason.clone()).await; manager.set_bootstrap_in_progress(false).await; let _ = app.emit("runtime:event", RuntimeEvent::RuntimeDegraded { reason: reason.clone() }); return Err(RuntimeError::RuntimeDegraded(reason)); } } } // Step 2: Check for saved credentials and attempt auto-login let creds = crate::credentials::load_qobuz_credentials(); let last_user_id = crate::user_data::UserDataPaths::load_last_user_id(); if let (Ok(Some(creds)), Some(user_id)) = (creds, last_user_id) { log::info!("[Runtime] Found saved credentials, attempting auto-login for user {}", user_id); // Login to legacy client let client = app_state.client.read().await; match client.login(&creds.email, &creds.password).await { Ok(session) => { log::info!("[Runtime] Legacy auth successful for user {}", session.user_id); manager.set_legacy_auth(true, Some(session.user_id)).await; let _ = app.emit("runtime:event", RuntimeEvent::AuthChanged { logged_in: true, user_id: Some(session.user_id), }); // Step 3: Activate per-user session // This is done by calling activate_user_session command // For now, we just mark the user_id and let the frontend handle it // In a full implementation, we'd activate here directly // Step 4: Authenticate CoreBridge/V2 - REQUIRED per ADR if let Some(bridge) = core_bridge.try_get().await { match bridge.login(&creds.email, &creds.password).await { Ok(_) => { log::info!("[Runtime] CoreBridge auth successful"); manager.set_corebridge_auth(true).await; } Err(e) => { log::error!("[Runtime] CoreBridge auth failed: {}", e); let _ = app.emit("runtime:event", RuntimeEvent::CoreBridgeAuthFailed { error: e.to_string(), }); manager.set_bootstrap_in_progress(false).await; return Err(RuntimeError::V2AuthFailed(e)); } } } else { log::error!("[Runtime] CoreBridge not initialized - cannot complete bootstrap"); manager.set_bootstrap_in_progress(false).await; return Err(RuntimeError::V2NotInitialized); } } Err(e) => { log::warn!("[Runtime] Auto-login failed: {}", e); // Not a fatal error - user can login manually } } } else { log::info!("[Runtime] No saved credentials or last user ID, staying in InitializedNoAuth"); } manager.set_bootstrap_in_progress(false).await; let status = manager.get_status().await; log::info!("[Runtime] Bootstrap complete: {:?}", status.state); Ok(status) } /// Emit a runtime event (internal helper) fn emit_runtime_event(app: &tauri::AppHandle, event: RuntimeEvent) { if let Err(e) = app.emit("runtime:event", &event) { log::warn!("[Runtime] Failed to emit event: {}", e); } } // ==================== Prefetch (V2) ==================== /// Number of Qobuz tracks to prefetch (not total tracks, just Qobuz) const V2_PREFETCH_COUNT: usize = 2; /// How far ahead to look for tracks to prefetch (to handle mixed playlists) const V2_PREFETCH_LOOKAHEAD: usize = 10; /// Maximum concurrent prefetch downloads const V2_MAX_CONCURRENT_PREFETCH: usize = 1; lazy_static::lazy_static! { /// Semaphore to limit concurrent prefetch operations static ref V2_PREFETCH_SEMAPHORE: tokio::sync::Semaphore = tokio::sync::Semaphore::new(V2_MAX_CONCURRENT_PREFETCH); } /// Spawn background tasks to prefetch upcoming Qobuz tracks (V2) fn spawn_v2_prefetch( bridge: Arc>>, cache: Arc, queue: &QueueManager, quality: Quality, streaming_only: bool, ) { // Skip prefetch entirely in streaming_only mode if streaming_only { log::debug!("[V2/PREFETCH] Skipped - streaming_only mode active"); return; } // Look further ahead to find Qobuz tracks in mixed playlists let upcoming_tracks = queue.peek_upcoming(V2_PREFETCH_LOOKAHEAD); if upcoming_tracks.is_empty() { log::debug!("[V2/PREFETCH] No upcoming tracks to prefetch"); return; } let mut qobuz_prefetched = 0; for track in upcoming_tracks { // Stop once we've prefetched enough Qobuz tracks if qobuz_prefetched >= V2_PREFETCH_COUNT { break; } let track_id = track.id; let track_title = track.title.clone(); // Skip local tracks - they don't need prefetching from Qobuz if track.is_local { log::debug!("[V2/PREFETCH] Skipping local track: {} - {}", track_id, track_title); continue; } // Check if already cached or being fetched if cache.contains(track_id) { log::debug!("[V2/PREFETCH] Track {} already cached", track_id); qobuz_prefetched += 1; continue; } if cache.is_fetching(track_id) { log::debug!("[V2/PREFETCH] Track {} already being fetched", track_id); qobuz_prefetched += 1; continue; } // Mark as fetching cache.mark_fetching(track_id); qobuz_prefetched += 1; let bridge_clone = bridge.clone(); let cache_clone = cache.clone(); log::info!("[V2/PREFETCH] Prefetching track: {} - {}", track_id, track_title); // Spawn background task for each track (with semaphore to limit concurrency) tokio::spawn(async move { // Acquire semaphore permit to limit concurrent prefetches let _permit = match V2_PREFETCH_SEMAPHORE.acquire().await { Ok(permit) => permit, Err(_) => { log::warn!("[V2/PREFETCH] Semaphore closed, skipping track {}", track_id); cache_clone.unmark_fetching(track_id); return; } }; let result = async { let bridge_guard = bridge_clone.read().await; let bridge = bridge_guard.as_ref().ok_or("CoreBridge not initialized")?; let stream_url = bridge.get_stream_url(track_id, quality).await?; drop(bridge_guard); let data = download_audio(&stream_url.url).await?; Ok::, String>(data) } .await; match result { Ok(data) => { // Small delay before cache insertion to avoid potential race with audio thread tokio::time::sleep(std::time::Duration::from_millis(50)).await; cache_clone.insert(track_id, data); log::info!("[V2/PREFETCH] Complete for track {}", track_id); } Err(e) => { log::warn!("[V2/PREFETCH] Failed for track {}: {}", track_id, e); } } cache_clone.unmark_fetching(track_id); }); } } // ==================== Auth Commands (V2) ==================== /// Check if user is logged in (V2 - uses QbzCore) #[tauri::command] pub async fn v2_is_logged_in( bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; Ok(bridge.is_logged_in().await) } /// Login with email and password (V2 - uses QbzCore) #[tauri::command] pub async fn v2_login( email: String, password: String, bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; bridge.login(&email, &password).await } /// Logout current user (V2 - uses QbzCore) #[tauri::command] pub async fn v2_logout( bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { let bridge = bridge.get().await; bridge.logout().await } // ==================== Queue Commands (V2) ==================== /// Get current queue state (V2 - uses QbzCore) #[tauri::command] pub async fn v2_get_queue_state( bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; Ok(bridge.get_queue_state().await) } /// Set repeat mode (V2 - uses QbzCore) #[tauri::command] pub async fn v2_set_repeat_mode( mode: RepeatMode, bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { let bridge = bridge.get().await; bridge.set_repeat_mode(mode).await; Ok(()) } /// Toggle shuffle (V2 - uses QbzCore) #[tauri::command] pub async fn v2_toggle_shuffle( bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; Ok(bridge.toggle_shuffle().await) } /// Set shuffle mode directly (V2) #[tauri::command] pub async fn v2_set_shuffle( enabled: bool, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] set_shuffle: {}", enabled); app_state.queue.set_shuffle(enabled); Ok(()) } /// Clear the queue (V2 - uses QbzCore) #[tauri::command] pub async fn v2_clear_queue( bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { let bridge = bridge.get().await; bridge.clear_queue().await; Ok(()) } /// Queue track representation for V2 commands /// Maps to internal QueueTrack format #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct V2QueueTrack { pub id: u64, pub title: String, pub artist: String, pub album: String, #[serde(rename = "duration")] pub duration_secs: u64, #[serde(rename = "artwork")] pub artwork_url: Option, #[serde(default)] pub hires: bool, pub bit_depth: Option, pub sample_rate: Option, #[serde(default)] pub is_local: bool, pub album_id: Option, pub artist_id: Option, #[serde(default = "default_streamable")] pub streamable: bool, /// Source type: "qobuz", "local", "plex" #[serde(default)] pub source: Option, } fn default_streamable() -> bool { true } impl From for crate::queue::QueueTrack { fn from(t: V2QueueTrack) -> Self { Self { id: t.id, title: t.title, artist: t.artist, album: t.album, duration_secs: t.duration_secs, artwork_url: t.artwork_url, hires: t.hires, bit_depth: t.bit_depth, sample_rate: t.sample_rate, is_local: t.is_local, album_id: t.album_id, artist_id: t.artist_id, streamable: t.streamable, source: t.source, } } } impl From for V2QueueTrack { fn from(t: crate::queue::QueueTrack) -> Self { Self { id: t.id, title: t.title, artist: t.artist, album: t.album, duration_secs: t.duration_secs, artwork_url: t.artwork_url, hires: t.hires, bit_depth: t.bit_depth, sample_rate: t.sample_rate, is_local: t.is_local, album_id: t.album_id, artist_id: t.artist_id, streamable: t.streamable, source: t.source, } } } /// Add track to the end of the queue (V2) #[tauri::command] pub async fn v2_add_to_queue( track: V2QueueTrack, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] add_to_queue: {} - {}", track.id, track.title); app_state.queue.add_track(track.into()); Ok(()) } /// Add track to play next (V2) #[tauri::command] pub async fn v2_add_to_queue_next( track: V2QueueTrack, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] add_to_queue_next: {} - {}", track.id, track.title); app_state.queue.add_track_next(track.into()); Ok(()) } /// Set the entire queue and start playing from index (V2) #[tauri::command] pub async fn v2_set_queue( tracks: Vec, start_index: usize, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] set_queue: {} tracks, start at {}", tracks.len(), start_index); let queue_tracks: Vec = tracks.into_iter().map(Into::into).collect(); app_state.queue.set_queue(queue_tracks, Some(start_index)); Ok(()) } /// Remove a track from the queue by index (V2) #[tauri::command] pub async fn v2_remove_from_queue( index: usize, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] remove_from_queue: index {}", index); app_state.queue.remove_track(index); Ok(()) } /// Remove a track from the upcoming queue by its position (V2) /// (0 = first upcoming track, handles shuffle mode correctly) #[tauri::command] pub async fn v2_remove_upcoming_track( upcoming_index: usize, app_state: State<'_, AppState>, ) -> Result, String> { log::info!("[V2] remove_upcoming_track: upcoming_index {}", upcoming_index); Ok(app_state.queue.remove_upcoming_track(upcoming_index).map(Into::into)) } /// Skip to next track in queue (V2) #[tauri::command] pub async fn v2_next_track( app_state: State<'_, AppState>, ) -> Result, String> { log::info!("[V2] next_track"); let track = app_state.queue.next(); Ok(track.map(Into::into)) } /// Go to previous track in queue (V2) #[tauri::command] pub async fn v2_previous_track( app_state: State<'_, AppState>, ) -> Result, String> { log::info!("[V2] previous_track"); let track = app_state.queue.previous(); Ok(track.map(Into::into)) } /// Play a specific track in the queue by index (V2) #[tauri::command] pub async fn v2_play_queue_index( index: usize, app_state: State<'_, AppState>, ) -> Result, String> { log::info!("[V2] play_queue_index: {}", index); let track = app_state.queue.play_index(index); Ok(track.map(Into::into)) } /// Move a track within the queue (V2) #[tauri::command] pub async fn v2_move_queue_track( from_index: usize, to_index: usize, app_state: State<'_, AppState>, ) -> Result { log::info!("[V2] move_queue_track: {} -> {}", from_index, to_index); Ok(app_state.queue.move_track(from_index, to_index)) } /// Add multiple tracks to queue (V2) #[tauri::command] pub async fn v2_add_tracks_to_queue( tracks: Vec, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] add_tracks_to_queue: {} tracks", tracks.len()); let queue_tracks: Vec = tracks.into_iter().map(|t| t.into()).collect(); app_state.queue.add_tracks(queue_tracks); Ok(()) } /// Add multiple tracks to play next (V2) /// Tracks are added in reverse order so they play in the order provided #[tauri::command] pub async fn v2_add_tracks_to_queue_next( tracks: Vec, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] add_tracks_to_queue_next: {} tracks", tracks.len()); // Add in reverse order so they end up in the correct order for track in tracks.into_iter().rev() { let queue_track: crate::queue::QueueTrack = track.into(); app_state.queue.add_track_next(queue_track); } Ok(()) } // ==================== Search Commands (V2) ==================== /// Search for albums (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_search_albums( query: String, limit: u32, offset: u32, searchType: Option, bridge: State<'_, CoreBridgeState>, blacklist_state: State<'_, BlacklistState>, ) -> Result, String> { let bridge = bridge.get().await; let mut results = bridge.search_albums(&query, limit, offset, searchType.as_deref()).await?; // Filter out albums from blacklisted artists let original_count = results.items.len(); results.items.retain(|album| !blacklist_state.is_blacklisted(album.artist.id)); let filtered_count = original_count - results.items.len(); if filtered_count > 0 { log::debug!("[V2/Blacklist] Filtered {} albums from search results", filtered_count); results.total = results.total.saturating_sub(filtered_count as u32); } Ok(results) } /// Search for tracks (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_search_tracks( query: String, limit: u32, offset: u32, searchType: Option, bridge: State<'_, CoreBridgeState>, blacklist_state: State<'_, BlacklistState>, ) -> Result, String> { let bridge = bridge.get().await; let mut results = bridge.search_tracks(&query, limit, offset, searchType.as_deref()).await?; // Filter out tracks from blacklisted artists let original_count = results.items.len(); results.items.retain(|track| { if let Some(ref performer) = track.performer { !blacklist_state.is_blacklisted(performer.id) } else { true // Keep tracks without performer info } }); let filtered_count = original_count - results.items.len(); if filtered_count > 0 { log::debug!("[V2/Blacklist] Filtered {} tracks from search results", filtered_count); results.total = results.total.saturating_sub(filtered_count as u32); } Ok(results) } /// Search for artists (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_search_artists( query: String, limit: u32, offset: u32, searchType: Option, bridge: State<'_, CoreBridgeState>, blacklist_state: State<'_, BlacklistState>, ) -> Result, String> { let bridge = bridge.get().await; let mut results = bridge.search_artists(&query, limit, offset, searchType.as_deref()).await?; // Filter out blacklisted artists let original_count = results.items.len(); results.items.retain(|artist| !blacklist_state.is_blacklisted(artist.id)); let filtered_count = original_count - results.items.len(); if filtered_count > 0 { log::debug!("[V2/Blacklist] Filtered {} artists from search results", filtered_count); results.total = results.total.saturating_sub(filtered_count as u32); } Ok(results) } // ==================== Catalog Commands (V2) ==================== /// Get album by ID (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_get_album( albumId: String, bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; bridge.get_album(&albumId).await } /// Get track by ID (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_get_track( trackId: u64, bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; bridge.get_track(trackId).await } /// Get artist by ID (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_get_artist( artistId: u64, bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; bridge.get_artist(artistId).await } // ==================== Favorites Commands (V2) ==================== /// Get favorites (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_get_favorites( favType: String, limit: u32, offset: u32, bridge: State<'_, CoreBridgeState>, ) -> Result { let bridge = bridge.get().await; bridge.get_favorites(&favType, limit, offset).await } /// Add item to favorites (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_add_favorite( favType: String, itemId: String, bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { log::info!("[V2] add_favorite type={} id={}", favType, itemId); let bridge = bridge.get().await; bridge.add_favorite(&favType, &itemId).await } /// Remove item from favorites (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_remove_favorite( favType: String, itemId: String, bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { log::info!("[V2] remove_favorite type={} id={}", favType, itemId); let bridge = bridge.get().await; bridge.remove_favorite(&favType, &itemId).await } // ==================== Playback Commands (V2) ==================== // // These commands use CoreBridge.player (qbz-player crate) for playback. // This is the V2 architecture - playback flows through QbzCore. /// Pause playback (V2) #[tauri::command] pub async fn v2_pause_playback( bridge: State<'_, CoreBridgeState>, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] Command: pause_playback"); app_state.media_controls.set_playback(false); let bridge = bridge.get().await; bridge.pause() } /// Resume playback (V2) #[tauri::command] pub async fn v2_resume_playback( bridge: State<'_, CoreBridgeState>, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] Command: resume_playback"); app_state.media_controls.set_playback(true); let bridge = bridge.get().await; bridge.resume() } /// Stop playback (V2) #[tauri::command] pub async fn v2_stop_playback( bridge: State<'_, CoreBridgeState>, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] Command: stop_playback"); app_state.media_controls.set_stopped(); let bridge = bridge.get().await; bridge.stop() } /// Seek to position in seconds (V2) #[tauri::command] pub async fn v2_seek( position: u64, bridge: State<'_, CoreBridgeState>, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] Command: seek {}", position); let bridge_guard = bridge.get().await; let result = bridge_guard.seek(position); // Update MPRIS with new position let playback_state = bridge_guard.get_playback_state(); app_state.media_controls.set_playback_with_progress( playback_state.is_playing, position, ); result } /// Set volume (0.0 - 1.0) (V2) #[tauri::command] pub async fn v2_set_volume( volume: f32, bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { let bridge = bridge.get().await; bridge.set_volume(volume) } /// Get current playback state (V2) - also updates MPRIS progress #[tauri::command] pub async fn v2_get_playback_state( bridge: State<'_, CoreBridgeState>, app_state: State<'_, AppState>, ) -> Result { let bridge = bridge.get().await; let playback_state = bridge.get_playback_state(); // Update MPRIS with current progress (called every ~500ms from frontend) app_state.media_controls.set_playback_with_progress( playback_state.is_playing, playback_state.position, ); Ok(playback_state) } /// Set media controls metadata (V2 - for MPRIS integration) #[tauri::command] pub async fn v2_set_media_metadata( title: String, artist: String, album: String, duration_secs: Option, cover_url: Option, app_state: State<'_, AppState>, ) -> Result<(), String> { log::info!("[V2] Command: set_media_metadata - {} by {}", title, artist); crate::update_media_controls_metadata( &app_state.media_controls, &title, &artist, &album, duration_secs, cover_url, ); app_state.media_controls.set_playback_with_progress(true, 0); Ok(()) } /// Queue next track for gapless playback (V2 - cache-only, no download) /// Returns true if gapless was queued, false if track not cached or ineligible #[tauri::command] pub async fn v2_play_next_gapless( track_id: u64, bridge: State<'_, CoreBridgeState>, offline_cache: State<'_, OfflineCacheState>, app_state: State<'_, AppState>, ) -> Result { log::info!("[V2] Command: play_next_gapless for track {}", track_id); let bridge_guard = bridge.get().await; let player = bridge_guard.player(); // Check offline cache (persistent disk cache) { let cached_path = { let db_opt = offline_cache.db.lock().await; if let Some(db) = db_opt.as_ref() { if let Ok(Some(file_path)) = db.get_file_path(track_id) { Some(file_path) } else { None } } else { None } }; if let Some(file_path) = cached_path { let path = std::path::Path::new(&file_path); if path.exists() { log::info!("[V2/GAPLESS] Track {} from OFFLINE cache", track_id); let audio_data = std::fs::read(path) .map_err(|e| format!("Failed to read cached file: {}", e))?; player.play_next(audio_data, track_id)?; return Ok(true); } } } // Check memory cache (L1) let cache = app_state.audio_cache.clone(); if let Some(cached) = cache.get(track_id) { log::info!("[V2/GAPLESS] Track {} from MEMORY cache ({} bytes)", track_id, cached.size_bytes); player.play_next(cached.data, track_id)?; return Ok(true); } // Check playback cache (L2 - disk) if let Some(playback_cache) = cache.get_playback_cache() { if let Some(audio_data) = playback_cache.get(track_id) { log::info!("[V2/GAPLESS] Track {} from DISK cache ({} bytes)", track_id, audio_data.len()); player.play_next(audio_data, track_id)?; return Ok(true); } } log::info!("[V2/GAPLESS] Track {} not in any cache, gapless not possible", track_id); Ok(false) } /// Prefetch a track into the in-memory cache without starting playback (V2) #[tauri::command] pub async fn v2_prefetch_track( track_id: u64, quality: Option, bridge: State<'_, CoreBridgeState>, offline_cache: State<'_, OfflineCacheState>, audio_settings: State<'_, AudioSettingsState>, app_state: State<'_, AppState>, ) -> Result<(), String> { let preferred_quality = parse_quality(quality.as_deref()); // Apply per-device sample rate limit if enabled let final_quality = { let guard = audio_settings .store .lock() .map_err(|e| format!("Lock error: {}", e))?; if let Some(store) = guard.as_ref() { if let Ok(settings) = store.get_settings() { if settings.limit_quality_to_device { let device_id = settings.output_device.as_deref().unwrap_or("default"); let max_rate = settings .device_sample_rate_limits .get(device_id) .copied() .or(settings.device_max_sample_rate); limit_quality_for_device(preferred_quality, max_rate) } else { preferred_quality } } else { preferred_quality } } else { preferred_quality } }; log::info!( "[V2] Command: prefetch_track {} (quality_str={:?}, parsed={:?}, final={:?})", track_id, quality, preferred_quality, final_quality ); let cache = app_state.audio_cache.clone(); if cache.contains(track_id) { log::info!("[V2] Track {} already in memory cache", track_id); return Ok(()); } if cache.is_fetching(track_id) { log::info!("[V2] Track {} already being fetched", track_id); return Ok(()); } cache.mark_fetching(track_id); let result = async { // Check persistent offline cache first { let cached_path = { let db_opt = offline_cache.db.lock().await; if let Some(db) = db_opt.as_ref() { db.get_file_path(track_id).ok().flatten() } else { None } }; if let Some(file_path) = cached_path { let path = std::path::Path::new(&file_path); if path.exists() { log::info!("[V2] Prefetching track {} from offline cache", track_id); let audio_data = std::fs::read(path) .map_err(|e| format!("Failed to read cached file: {}", e))?; cache.insert(track_id, audio_data); return Ok(()); } } } let bridge_guard = bridge.get().await; let stream_url = bridge_guard.get_stream_url(track_id, final_quality).await?; drop(bridge_guard); let audio_data = download_audio(&stream_url.url).await?; cache.insert(track_id, audio_data); Ok(()) } .await; cache.unmark_fetching(track_id); result } /// Result from play_track command with format info #[derive(serde::Serialize)] pub struct V2PlayTrackResult { /// The actual format_id returned by Qobuz (5=MP3, 6=FLAC 16-bit, 7=24-bit, 27=Hi-Res) /// None when playing from cache (format unknown) pub format_id: Option, } /// Play a track by ID (V2 - uses CoreBridge for API and playback) /// /// This is the core playback command that: /// 1. Checks caches (offline, memory, disk) /// 2. Gets stream URL from Qobuz via CoreBridge /// 3. Downloads audio /// 4. Plays via CoreBridge.player() (qbz-player crate) /// 5. Caches for future playback #[tauri::command] pub async fn v2_play_track( track_id: u64, quality: Option, bridge: State<'_, CoreBridgeState>, offline_cache: State<'_, OfflineCacheState>, audio_settings: State<'_, AudioSettingsState>, app_state: State<'_, AppState>, ) -> Result { let preferred_quality = parse_quality(quality.as_deref()); // Apply per-device sample rate limit if enabled let final_quality = { let guard = audio_settings .store .lock() .map_err(|e| format!("Lock error: {}", e))?; if let Some(store) = guard.as_ref() { if let Ok(settings) = store.get_settings() { if settings.limit_quality_to_device { let device_id = settings.output_device.as_deref().unwrap_or("default"); let max_rate = settings .device_sample_rate_limits .get(device_id) .copied() .or(settings.device_max_sample_rate); limit_quality_for_device(preferred_quality, max_rate) } else { preferred_quality } } else { preferred_quality } } else { preferred_quality } }; // Check streaming_only setting let streaming_only = { let guard = audio_settings.store.lock().map_err(|e| format!("Lock error: {}", e))?; guard.as_ref().and_then(|s| s.get_settings().ok()).map(|s| s.streaming_only).unwrap_or(false) }; log::info!( "[V2] play_track {} (quality_str={:?}, parsed={:?}, final={:?}, format_id={})", track_id, quality, preferred_quality, final_quality, final_quality.id() ); let bridge_guard = bridge.get().await; let player = bridge_guard.player(); // Check offline cache (persistent disk cache) { let cached_path = { let db_opt = offline_cache.db.lock().await; if let Some(db) = db_opt.as_ref() { if let Ok(Some(file_path)) = db.get_file_path(track_id) { let _ = db.touch(track_id); Some(file_path) } else { None } } else { None } }; if let Some(file_path) = cached_path { let path = std::path::Path::new(&file_path); if path.exists() { log::info!("[V2/CACHE HIT] Track {} from OFFLINE cache: {:?}", track_id, path); let audio_data = std::fs::read(path) .map_err(|e| format!("Failed to read cached file: {}", e))?; player.play_data(audio_data, track_id)?; // Prefetch next tracks in background drop(bridge_guard); spawn_v2_prefetch(bridge.0.clone(), app_state.audio_cache.clone(), &app_state.queue, final_quality, streaming_only); return Ok(V2PlayTrackResult { format_id: None }); } } } // Check memory cache (L1) - using AppState's audio_cache for now // TODO: Move cache to qbz-core in future refactor let cache = app_state.audio_cache.clone(); if let Some(cached) = cache.get(track_id) { log::info!("[V2/CACHE HIT] Track {} from MEMORY cache ({} bytes)", track_id, cached.size_bytes); player.play_data(cached.data, track_id)?; // Prefetch next tracks in background drop(bridge_guard); spawn_v2_prefetch(bridge.0.clone(), cache.clone(), &app_state.queue, final_quality, streaming_only); return Ok(V2PlayTrackResult { format_id: None }); } // Check playback cache (L2 - disk) if let Some(playback_cache) = cache.get_playback_cache() { if let Some(audio_data) = playback_cache.get(track_id) { log::info!("[V2/CACHE HIT] Track {} from DISK cache ({} bytes)", track_id, audio_data.len()); cache.insert(track_id, audio_data.clone()); player.play_data(audio_data, track_id)?; // Prefetch next tracks in background drop(bridge_guard); spawn_v2_prefetch(bridge.0.clone(), cache.clone(), &app_state.queue, final_quality, streaming_only); return Ok(V2PlayTrackResult { format_id: None }); } } // Not in any cache - get stream URL from Qobuz via CoreBridge log::info!("[V2] Track {} not in cache, fetching from network...", track_id); let stream_url = bridge_guard.get_stream_url(track_id, final_quality).await?; log::info!("[V2] Got stream URL for track {} (format_id={})", track_id, stream_url.format_id); // Download the audio let audio_data = download_audio(&stream_url.url).await?; let data_size = audio_data.len(); // Cache it (unless streaming_only mode) if !streaming_only { cache.insert(track_id, audio_data.clone()); log::info!("[V2/CACHED] Track {} stored in memory cache", track_id); } else { log::info!("[V2/NOT CACHED] Track {} - streaming_only mode active", track_id); } // Play it via qbz-player player.play_data(audio_data, track_id)?; log::info!("[V2] Playing track {} ({} bytes)", track_id, data_size); // Prefetch next tracks in background drop(bridge_guard); spawn_v2_prefetch(bridge.0.clone(), cache, &app_state.queue, final_quality, streaming_only); Ok(V2PlayTrackResult { format_id: Some(stream_url.format_id) }) } // ==================== Audio Device Commands (V2) ==================== /// Reinitialize audio device (V2 - uses CoreBridge.player) /// Call this when changing audio settings like exclusive mode or output device #[tauri::command] pub async fn v2_reinit_audio_device( device: Option, bridge: State<'_, CoreBridgeState>, audio_settings: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] Command: reinit_audio_device {:?}", device); let bridge_guard = bridge.get().await; let player = bridge_guard.player(); // Reload settings from database to ensure Player has latest config if let Ok(guard) = audio_settings.store.lock() { if let Some(store) = guard.as_ref() { if let Ok(fresh_settings) = store.get_settings() { log::info!( "[V2] Reloading audio settings before reinit (backend_type: {:?})", fresh_settings.backend_type ); // Convert to qbz_audio::AudioSettings let qbz_settings = qbz_audio::AudioSettings { output_device: fresh_settings.output_device.clone(), exclusive_mode: fresh_settings.exclusive_mode, dac_passthrough: fresh_settings.dac_passthrough, preferred_sample_rate: fresh_settings.preferred_sample_rate, limit_quality_to_device: fresh_settings.limit_quality_to_device, device_max_sample_rate: fresh_settings.device_max_sample_rate, device_sample_rate_limits: fresh_settings.device_sample_rate_limits.clone(), backend_type: fresh_settings.backend_type.clone(), alsa_plugin: fresh_settings.alsa_plugin.clone(), alsa_hardware_volume: false, // Not exposed in legacy UI stream_first_track: fresh_settings.stream_first_track, stream_buffer_seconds: fresh_settings.stream_buffer_seconds, streaming_only: fresh_settings.streaming_only, normalization_enabled: fresh_settings.normalization_enabled, normalization_target_lufs: fresh_settings.normalization_target_lufs, gapless_enabled: fresh_settings.gapless_enabled, }; let _ = player.reload_settings(qbz_settings); } } } player.reinit_device(device) } // ==================== Playlist Commands (V2) ==================== /// Get user playlists (V2 - uses QbzCore) #[tauri::command] pub async fn v2_get_user_playlists( bridge: State<'_, CoreBridgeState>, ) -> Result, String> { log::info!("[V2] get_user_playlists"); let bridge = bridge.get().await; bridge.get_user_playlists().await } /// Get playlist by ID (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_get_playlist( playlistId: u64, bridge: State<'_, CoreBridgeState>, ) -> Result { log::info!("[V2] get_playlist: {}", playlistId); let bridge = bridge.get().await; bridge.get_playlist(playlistId).await } /// Add tracks to playlist (V2 - uses QbzCore) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_add_tracks_to_playlist( playlistId: u64, trackIds: Vec, bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { log::info!("[V2] add_tracks_to_playlist: playlist {} <- {} tracks", playlistId, trackIds.len()); let bridge = bridge.get().await; bridge.add_tracks_to_playlist(playlistId, &trackIds).await } /// Remove tracks from playlist (V2 - uses QbzCore) /// Accepts either playlistTrackIds (direct) or trackIds (requires resolution) #[tauri::command] #[allow(non_snake_case)] pub async fn v2_remove_tracks_from_playlist( playlistId: u64, playlistTrackIds: Option>, trackIds: Option>, bridge: State<'_, CoreBridgeState>, ) -> Result<(), String> { let ptids = playlistTrackIds.unwrap_or_default(); let tids = trackIds.unwrap_or_default(); log::info!( "[V2] remove_tracks_from_playlist: playlist {} (playlistTrackIds={}, trackIds={})", playlistId, ptids.len(), tids.len() ); let bridge = bridge.get().await; // If we have direct playlist_track_ids, use them if !ptids.is_empty() { return bridge.remove_tracks_from_playlist(playlistId, &ptids).await; } // Otherwise resolve track_ids → playlist_track_ids via full playlist fetch if !tids.is_empty() { let playlist = bridge.get_playlist(playlistId).await?; let track_id_set: std::collections::HashSet = tids.into_iter().collect(); let resolved_ptids: Vec = playlist .tracks .map(|tc| { tc.items .into_iter() .filter(|track| track_id_set.contains(&track.id)) .filter_map(|track| track.playlist_track_id) .collect() }) .unwrap_or_default(); if resolved_ptids.is_empty() { return Err("Could not resolve any track IDs to playlist track IDs".to_string()); } return bridge.remove_tracks_from_playlist(playlistId, &resolved_ptids).await; } Err("Either playlistTrackIds or trackIds must be provided".to_string()) } // ==================== Audio Settings Commands (V2) ==================== /// Get current audio settings (V2) #[tauri::command] pub fn v2_get_audio_settings( state: State<'_, AudioSettingsState>, ) -> Result { log::info!("[V2] get_audio_settings"); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.get_settings() } /// Set audio output device (V2) #[tauri::command] pub fn v2_set_audio_output_device( device: Option, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { let normalized_device = device .as_ref() .map(|d| crate::audio::normalize_device_id_to_stable(d)); log::info!( "[V2] set_audio_output_device {:?} -> {:?} (normalized)", device, normalized_device ); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_output_device(normalized_device.as_deref()) } /// Set audio exclusive mode (V2) #[tauri::command] pub fn v2_set_audio_exclusive_mode( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_exclusive_mode: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_exclusive_mode(enabled) } /// Set DAC passthrough mode (V2) #[tauri::command] pub fn v2_set_audio_dac_passthrough( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_dac_passthrough: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_dac_passthrough(enabled) } /// Set preferred sample rate (V2) #[tauri::command] pub fn v2_set_audio_sample_rate( rate: Option, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_sample_rate: {:?}", rate); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_sample_rate(rate) } /// Set audio backend type (V2) #[tauri::command] #[allow(non_snake_case)] pub fn v2_set_audio_backend_type( backendType: Option, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_backend_type: {:?}", backendType); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_backend_type(backendType) } /// Set ALSA plugin (V2) #[tauri::command] pub fn v2_set_audio_alsa_plugin( plugin: Option, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_alsa_plugin: {:?}", plugin); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_alsa_plugin(plugin) } /// Set gapless playback enabled (V2) #[tauri::command] pub fn v2_set_audio_gapless_enabled( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_gapless_enabled: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_gapless_enabled(enabled) } /// Set normalization enabled (V2) #[tauri::command] pub fn v2_set_audio_normalization_enabled( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_normalization_enabled: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_normalization_enabled(enabled) } /// Set normalization target LUFS (V2) #[tauri::command] pub fn v2_set_audio_normalization_target( target: f32, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_normalization_target: {}", target); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_normalization_target_lufs(target) } /// Set device max sample rate (V2) #[tauri::command] pub fn v2_set_audio_device_max_sample_rate( rate: Option, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_device_max_sample_rate: {:?}", rate); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_device_max_sample_rate(rate) } /// Set limit quality to device capability (V2) #[tauri::command] pub fn v2_set_audio_limit_quality_to_device( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_limit_quality_to_device: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_limit_quality_to_device(enabled) } /// Set streaming only mode (V2) #[tauri::command] pub fn v2_set_audio_streaming_only( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_streaming_only: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_streaming_only(enabled) } /// Reset audio settings to defaults (V2) #[tauri::command] pub fn v2_reset_audio_settings( state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] reset_audio_settings"); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.reset_all().map(|_| ()) } /// Set stream first track enabled (V2) #[tauri::command] pub fn v2_set_audio_stream_first_track( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_stream_first_track: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_stream_first_track(enabled) } /// Set stream buffer seconds (V2) #[tauri::command] pub fn v2_set_audio_stream_buffer_seconds( seconds: u8, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_stream_buffer_seconds: {}", seconds); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_stream_buffer_seconds(seconds) } /// Set ALSA hardware volume control (V2) #[tauri::command] pub fn v2_set_audio_alsa_hardware_volume( enabled: bool, state: State<'_, AudioSettingsState>, ) -> Result<(), String> { log::info!("[V2] set_audio_alsa_hardware_volume: {}", enabled); let guard = state .store .lock() .map_err(|e| format!("Lock error: {}", e))?; let store = guard.as_ref().ok_or("No active session - please log in")?; store.set_alsa_hardware_volume(enabled) }