diff --git a/crates/qbz-core/src/core.rs b/crates/qbz-core/src/core.rs index 748e4af7a..4e59726df 100644 --- a/crates/qbz-core/src/core.rs +++ b/crates/qbz-core/src/core.rs @@ -9,7 +9,7 @@ use tokio::sync::RwLock; use qbz_models::{ Album, Artist, CoreEvent, DiscoverAlbum, DiscoverData, DiscoverPlaylistsResponse, DiscoverResponse, FrontendAdapter, GenreInfo, LabelDetail, PageArtistResponse, Playlist, - PlaylistTag, Quality, QueueState, RepeatMode, SearchResultsPage, StreamUrl, Track, UserSession, + PlaylistTag, Quality, QueueState, QueueTrack, RepeatMode, SearchResultsPage, StreamUrl, Track, UserSession, }; use qbz_player::{Player, PlaybackState, QueueManager}; use qbz_qobuz::QobuzClient; @@ -163,6 +163,120 @@ impl QbzCore { .await; } + /// Add a track to the end of the queue + pub async fn add_track(&self, track: QueueTrack) { + let queue = self.queue.write().await; + queue.add_track(track); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + } + + /// Add multiple tracks to the queue + pub async fn add_tracks(&self, tracks: Vec) { + let queue = self.queue.write().await; + queue.add_tracks(tracks); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + } + + /// Add a track to play next (after current) + pub async fn add_track_next(&self, track: QueueTrack) { + let queue = self.queue.write().await; + queue.add_track_next(track); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + } + + /// Set the entire queue (replaces existing) + pub async fn set_queue(&self, tracks: Vec, start_index: Option) { + let queue = self.queue.write().await; + queue.set_queue(tracks, start_index); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + } + + /// Remove a track by index + pub async fn remove_track(&self, index: usize) -> Option { + let queue = self.queue.write().await; + let removed = queue.remove_track(index); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + removed + } + + /// Remove a track from the upcoming list by position + pub async fn remove_upcoming_track(&self, upcoming_index: usize) -> Option { + let queue = self.queue.write().await; + let removed = queue.remove_upcoming_track(upcoming_index); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + removed + } + + /// Move a track from one position to another + pub async fn move_track(&self, from_index: usize, to_index: usize) -> bool { + let queue = self.queue.write().await; + let success = queue.move_track(from_index, to_index); + if success { + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + } + success + } + + /// Jump to a specific track by index + pub async fn play_index(&self, index: usize) -> Option { + let queue = self.queue.write().await; + let track = queue.play_index(index); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + track + } + + /// Advance to next track in queue + pub async fn next_track(&self) -> Option { + let queue = self.queue.write().await; + let track = queue.next(); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + track + } + + /// Go to previous track in queue + pub async fn previous_track(&self) -> Option { + let queue = self.queue.write().await; + let track = queue.previous(); + self.emit(CoreEvent::QueueUpdated { + state: queue.get_state(), + }) + .await; + track + } + + /// Get multiple upcoming tracks without advancing (for prefetching) + pub async fn peek_upcoming(&self, count: usize) -> Vec { + let queue = self.queue.read().await; + queue.peek_upcoming(count) + } + // ==================== Search & Catalog ==================== /// Search for albums diff --git a/src-tauri/src/commands_v2.rs b/src-tauri/src/commands_v2.rs index b270b79f4..5892794af 100644 --- a/src-tauri/src/commands_v2.rs +++ b/src-tauri/src/commands_v2.rs @@ -12,7 +12,7 @@ use tokio::sync::RwLock; use qbz_models::{ Album, Artist, DiscoverAlbum, DiscoverData, DiscoverPlaylistsResponse, DiscoverResponse, GenreInfo, LabelDetail, PageArtistResponse, Playlist, PlaylistTag, Quality, QueueState, - RepeatMode, SearchResultsPage, Track, UserSession, + QueueTrack as CoreQueueTrack, RepeatMode, SearchResultsPage, Track, UserSession, }; use crate::artist_blacklist::BlacklistState; @@ -22,7 +22,6 @@ use crate::config::audio_settings::{AudioSettings, AudioSettingsState}; use crate::config::legal_settings::LegalSettingsState; use crate::core_bridge::CoreBridgeState; use crate::offline_cache::OfflineCacheState; -use crate::queue::QueueManager; use crate::runtime::{RuntimeManagerState, RuntimeStatus, RuntimeError, RuntimeEvent, DegradedReason, CommandRequirement}; use crate::AppState; @@ -69,6 +68,7 @@ async fn rollback_auth_state( log::warn!("[V2] Rolling back auth state after partial login failure"); manager.set_legacy_auth(false, None).await; manager.set_corebridge_auth(false).await; + manager.set_session_activated(false, 0).await; let _ = app.emit("runtime:event", RuntimeEvent::AuthChanged { logged_in: false, user_id: None, @@ -675,10 +675,11 @@ lazy_static::lazy_static! { } /// Spawn background tasks to prefetch upcoming Qobuz tracks (V2) +/// Takes upcoming tracks directly from CoreBridge (not legacy AppState queue) fn spawn_v2_prefetch( bridge: Arc>>, cache: Arc, - queue: &QueueManager, + upcoming_tracks: Vec, quality: Quality, streaming_only: bool, ) { @@ -688,8 +689,8 @@ fn spawn_v2_prefetch( return; } - // Look further ahead to find Qobuz tracks in mixed playlists - let upcoming_tracks = queue.peek_upcoming(V2_PREFETCH_LOOKAHEAD); + // upcoming_tracks already provided by caller from CoreBridge + let upcoming_tracks = upcoming_tracks; if upcoming_tracks.is_empty() { log::debug!("[V2/PREFETCH] No upcoming tracks to prefetch"); @@ -928,21 +929,22 @@ pub async fn v2_toggle_shuffle( bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result { - runtime.manager().check_requirements(CommandRequirement::RequiresCoreBridgeAuth).await?; + runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; let bridge = bridge.get().await; Ok(bridge.toggle_shuffle().await) } -/// Set shuffle mode directly (V2) +/// Set shuffle mode directly (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_set_shuffle( enabled: bool, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] set_shuffle: {}", enabled); - app_state.queue.set_shuffle(enabled); + let bridge = bridge.get().await; + bridge.set_shuffle(enabled).await; Ok(()) } @@ -952,7 +954,7 @@ pub async fn v2_clear_queue( bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { - runtime.manager().check_requirements(CommandRequirement::RequiresCoreBridgeAuth).await?; + runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; let bridge = bridge.get().await; bridge.clear_queue().await; Ok(()) @@ -1031,151 +1033,204 @@ impl From for V2QueueTrack { } } -/// Add track to the end of the queue (V2) +// V2 queue track <-> qbz_models::QueueTrack (CoreQueueTrack) +impl From for CoreQueueTrack { + 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: CoreQueueTrack) -> 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 - uses CoreBridge) #[tauri::command] pub async fn v2_add_to_queue( track: V2QueueTrack, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] add_to_queue: {} - {}", track.id, track.title); - app_state.queue.add_track(track.into()); + let bridge = bridge.get().await; + bridge.add_track(track.into()).await; Ok(()) } -/// Add track to play next (V2) +/// Add track to play next (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_add_to_queue_next( track: V2QueueTrack, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] add_to_queue_next: {} - {}", track.id, track.title); - app_state.queue.add_track_next(track.into()); + let bridge = bridge.get().await; + bridge.add_track_next(track.into()).await; Ok(()) } -/// Set the entire queue and start playing from index (V2) +/// Set the entire queue and start playing from index (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_set_queue( tracks: Vec, start_index: usize, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; 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)); + let queue_tracks: Vec = tracks.into_iter().map(Into::into).collect(); + let bridge = bridge.get().await; + bridge.set_queue(queue_tracks, Some(start_index)).await; Ok(()) } -/// Remove a track from the queue by index (V2) +/// Remove a track from the queue by index (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_remove_from_queue( index: usize, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] remove_from_queue: index {}", index); - app_state.queue.remove_track(index); + let bridge = bridge.get().await; + bridge.remove_track(index).await; Ok(()) } -/// Remove a track from the upcoming queue by its position (V2) +/// Remove a track from the upcoming queue by its position (V2 - uses CoreBridge) /// (0 = first upcoming track, handles shuffle mode correctly) #[tauri::command] pub async fn v2_remove_upcoming_track( upcoming_index: usize, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result, RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] remove_upcoming_track: upcoming_index {}", upcoming_index); - Ok(app_state.queue.remove_upcoming_track(upcoming_index).map(Into::into)) + let bridge = bridge.get().await; + Ok(bridge.remove_upcoming_track(upcoming_index).await.map(Into::into)) } -/// Skip to next track in queue (V2) +/// Skip to next track in queue (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_next_track( - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result, RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] next_track"); - let track = app_state.queue.next(); + let bridge = bridge.get().await; + let track = bridge.next_track().await; Ok(track.map(Into::into)) } -/// Go to previous track in queue (V2) +/// Go to previous track in queue (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_previous_track( - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result, RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] previous_track"); - let track = app_state.queue.previous(); + let bridge = bridge.get().await; + let track = bridge.previous_track().await; Ok(track.map(Into::into)) } -/// Play a specific track in the queue by index (V2) +/// Play a specific track in the queue by index (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_play_queue_index( index: usize, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result, RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] play_queue_index: {}", index); - let track = app_state.queue.play_index(index); + let bridge = bridge.get().await; + let track = bridge.play_index(index).await; Ok(track.map(Into::into)) } -/// Move a track within the queue (V2) +/// Move a track within the queue (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_move_queue_track( from_index: usize, to_index: usize, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] move_queue_track: {} -> {}", from_index, to_index); - Ok(app_state.queue.move_track(from_index, to_index)) + let bridge = bridge.get().await; + Ok(bridge.move_track(from_index, to_index).await) } -/// Add multiple tracks to queue (V2) +/// Add multiple tracks to queue (V2 - uses CoreBridge) #[tauri::command] pub async fn v2_add_tracks_to_queue( tracks: Vec, - app_state: State<'_, AppState>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; 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); + let queue_tracks: Vec = tracks.into_iter().map(Into::into).collect(); + let bridge = bridge.get().await; + bridge.add_tracks(queue_tracks).await; Ok(()) } -/// Add multiple tracks to play next (V2) +/// Add multiple tracks to play next (V2 - uses CoreBridge) /// 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>, + bridge: State<'_, CoreBridgeState>, runtime: State<'_, RuntimeManagerState>, ) -> Result<(), RuntimeError> { runtime.manager().check_requirements(CommandRequirement::RequiresUserSession).await?; log::info!("[V2] add_tracks_to_queue_next: {} tracks", tracks.len()); + let bridge = bridge.get().await; // 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); + bridge.add_track_next(track.into()).await; } Ok(()) } @@ -1755,9 +1810,10 @@ pub async fn v2_play_track( player.play_data(audio_data, track_id) .map_err(RuntimeError::Internal)?; - // Prefetch next tracks in background + // Prefetch next tracks in background (using CoreBridge queue) + let upcoming_tracks = bridge_guard.peek_upcoming(V2_PREFETCH_LOOKAHEAD).await; drop(bridge_guard); - spawn_v2_prefetch(bridge.0.clone(), app_state.audio_cache.clone(), &app_state.queue, final_quality, streaming_only); + spawn_v2_prefetch(bridge.0.clone(), app_state.audio_cache.clone(), upcoming_tracks, final_quality, streaming_only); return Ok(V2PlayTrackResult { format_id: None }); } } @@ -1771,9 +1827,10 @@ pub async fn v2_play_track( player.play_data(cached.data, track_id) .map_err(RuntimeError::Internal)?; - // Prefetch next tracks in background + // Prefetch next tracks in background (using CoreBridge queue) + let upcoming_tracks = bridge_guard.peek_upcoming(V2_PREFETCH_LOOKAHEAD).await; drop(bridge_guard); - spawn_v2_prefetch(bridge.0.clone(), cache.clone(), &app_state.queue, final_quality, streaming_only); + spawn_v2_prefetch(bridge.0.clone(), cache.clone(), upcoming_tracks, final_quality, streaming_only); return Ok(V2PlayTrackResult { format_id: None }); } @@ -1785,9 +1842,10 @@ pub async fn v2_play_track( player.play_data(audio_data, track_id) .map_err(RuntimeError::Internal)?; - // Prefetch next tracks in background + // Prefetch next tracks in background (using CoreBridge queue) + let upcoming_tracks = bridge_guard.peek_upcoming(V2_PREFETCH_LOOKAHEAD).await; drop(bridge_guard); - spawn_v2_prefetch(bridge.0.clone(), cache.clone(), &app_state.queue, final_quality, streaming_only); + spawn_v2_prefetch(bridge.0.clone(), cache.clone(), upcoming_tracks, final_quality, streaming_only); return Ok(V2PlayTrackResult { format_id: None }); } } @@ -1817,9 +1875,10 @@ pub async fn v2_play_track( .map_err(RuntimeError::Internal)?; log::info!("[V2] Playing track {} ({} bytes)", track_id, data_size); - // Prefetch next tracks in background + // Prefetch next tracks in background (using CoreBridge queue) + let upcoming_tracks = bridge_guard.peek_upcoming(V2_PREFETCH_LOOKAHEAD).await; drop(bridge_guard); - spawn_v2_prefetch(bridge.0.clone(), cache, &app_state.queue, final_quality, streaming_only); + spawn_v2_prefetch(bridge.0.clone(), cache, upcoming_tracks, final_quality, streaming_only); Ok(V2PlayTrackResult { format_id: Some(stream_url.format_id) }) } diff --git a/src-tauri/src/core_bridge.rs b/src-tauri/src/core_bridge.rs index a8561f50b..43d8479eb 100644 --- a/src-tauri/src/core_bridge.rs +++ b/src-tauri/src/core_bridge.rs @@ -14,7 +14,7 @@ use qbz_core::QbzCore; use qbz_models::{ Album, Artist, DiscoverAlbum, DiscoverData, DiscoverPlaylistsResponse, DiscoverResponse, GenreInfo, LabelDetail, PageArtistResponse, Playlist, PlaylistTag, Quality, QueueState, - RepeatMode, SearchResultsPage, StreamUrl, Track, UserSession, + QueueTrack, RepeatMode, SearchResultsPage, StreamUrl, Track, UserSession, }; use qbz_player::{Player, PlaybackState}; use qbz_audio::{AudioSettings, AudioDiagnostic, settings::AudioSettingsStore}; @@ -108,11 +108,71 @@ impl CoreBridge { self.core.toggle_shuffle().await } + /// Set shuffle mode directly + pub async fn set_shuffle(&self, enabled: bool) { + self.core.set_shuffle(enabled).await + } + /// Clear the queue pub async fn clear_queue(&self) { self.core.clear_queue().await } + /// Add a track to the end of the queue + pub async fn add_track(&self, track: QueueTrack) { + self.core.add_track(track).await + } + + /// Add multiple tracks to the queue + pub async fn add_tracks(&self, tracks: Vec) { + self.core.add_tracks(tracks).await + } + + /// Add a track to play next (after current) + pub async fn add_track_next(&self, track: QueueTrack) { + self.core.add_track_next(track).await + } + + /// Set the entire queue (replaces existing) + pub async fn set_queue(&self, tracks: Vec, start_index: Option) { + self.core.set_queue(tracks, start_index).await + } + + /// Remove a track by index + pub async fn remove_track(&self, index: usize) -> Option { + self.core.remove_track(index).await + } + + /// Remove a track from the upcoming list by position + pub async fn remove_upcoming_track(&self, upcoming_index: usize) -> Option { + self.core.remove_upcoming_track(upcoming_index).await + } + + /// Move a track from one position to another + pub async fn move_track(&self, from_index: usize, to_index: usize) -> bool { + self.core.move_track(from_index, to_index).await + } + + /// Jump to a specific track by index + pub async fn play_index(&self, index: usize) -> Option { + self.core.play_index(index).await + } + + /// Advance to next track in queue + pub async fn next_track(&self) -> Option { + self.core.next_track().await + } + + /// Go to previous track in queue + pub async fn previous_track(&self) -> Option { + self.core.previous_track().await + } + + /// Get multiple upcoming tracks without advancing (for prefetching) + pub async fn peek_upcoming(&self, count: usize) -> Vec { + self.core.peek_upcoming(count).await + } + // ==================== Search & Catalog ==================== /// Search for albums diff --git a/src/lib/stores/queueStore.test.ts b/src/lib/stores/queueStore.test.ts index d488529a4..1692f7b59 100644 --- a/src/lib/stores/queueStore.test.ts +++ b/src/lib/stores/queueStore.test.ts @@ -134,7 +134,8 @@ describe('queueStore', () => { artwork: 'http://art.jpg', title: 'Song 1', artist: 'Artist', - duration: '3:00' + duration: '3:00', + available: true }); expect(getQueue()[1].duration).toBe('4:00'); expect(getQueueTotalTracks()).toBe(5); @@ -179,7 +180,7 @@ describe('queueStore', () => { expect(result).toEqual({ success: true, enabled: true }); expect(getIsShuffle()).toBe(true); - expect(mockedInvoke).toHaveBeenCalledWith('set_shuffle', { enabled: true }); + expect(mockedInvoke).toHaveBeenCalledWith('v2_toggle_shuffle'); }); it('should toggle shuffle off', async () => {