fix(v2): unify queue architecture - all commands use CoreBridge

Previously, V2 queue commands had a dual-queue bug:
- Writes (v2_set_queue, v2_add_to_queue, etc.) went to AppState.queue (legacy)
- Reads (v2_get_queue_state) came from CoreBridge/QbzCore queue
- Result: frontend sets queue, syncs, gets empty/stale data

This commit fixes the architecture:
- All V2 queue commands now use CoreBridge methods
- Added queue methods to QbzCore: add_track, add_tracks, add_track_next,
  set_queue, remove_track, remove_upcoming_track, move_track, play_index,
  next_track, previous_track, peek_upcoming
- Added corresponding methods to CoreBridge
- Fixed v2_set_shuffle to use CoreBridge (was using legacy AppState)
- Fixed runtime requirements: v2_toggle_shuffle and v2_clear_queue now
  use RequiresUserSession like other queue commands (consistency)
- Prefetch now gets upcoming tracks from CoreBridge, not legacy queue
- Updated tests to match V2 behavior (v2_toggle_shuffle, available field)
This commit is contained in:
vicrodh committed 2026-02-15 20:07:01 -06:00
1 parent 8d26f547d1
commit 045cf24a61
4 files changed
+292 -58

No files matched your search

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