Joren/qobuz-qt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: resync with qbqt baseline and restore genre browser
Some checks failed
Build for Windows / build-windows (push) Has been cancelled
Details

Browse Source
This commit is contained in:
joren
2026-03-30 22:36:39 +02:00
parent 200ef39d04
commit 3346b424b3
26 changed files with 8533 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
rust/include/qobuz_backend.h
View File

@@ -37,6 +37,8 @@ enum QobuzEvent {
EV_USER_OK = 23,
EV_ARTIST_RELEASES_OK = 24,
EV_DEEP_SHUFFLE_OK = 25,
EV_GENRES_OK = 27,
EV_FEATURED_ALBUMS_OK = 28,
};
// Callback signature
@@ -53,7 +55,6 @@ void qobuz_backend_get_user(QobuzBackendOpaque *backend);
// Catalog
void qobuz_backend_search(QobuzBackendOpaque *backend, const char *query, uint32_t offset, uint32_t limit);
void qobuz_backend_most_popular_search(QobuzBackendOpaque *backend, const char *query, uint32_t limit);
void qobuz_backend_get_album(QobuzBackendOpaque *backend, const char *album_id);
void qobuz_backend_get_artist(QobuzBackendOpaque *backend, int64_t artist_id);
void qobuz_backend_get_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, uint32_t offset, uint32_t limit);
@@ -89,6 +90,10 @@ void qobuz_backend_get_artist_releases(QobuzBackendOpaque *backend, int64_t arti
// Deep shuffle: fetch tracks from multiple albums (album_ids_json is a JSON array of strings)
void qobuz_backend_get_albums_tracks(QobuzBackendOpaque *backend, const char *album_ids_json);
// Browse
void qobuz_backend_get_genres(QobuzBackendOpaque *backend);
void qobuz_backend_get_featured_albums(QobuzBackendOpaque *backend, int64_t genre_id, const char *kind, uint32_t limit, uint32_t offset);
// Playlist management
void qobuz_backend_create_playlist(QobuzBackendOpaque *backend, const char *name);
void qobuz_backend_delete_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);

232
rust/src/api/client.rs
View File

@@ -40,7 +40,11 @@ fn b64url_decode(s: &str) -> Result<Vec<u8>> {
/// Full qbz-1 key derivation:
/// Phase 1: HKDF-SHA256(ikm=hex(app_secret), salt=b64url(infos[0]), info=b64url(infos[1])) → 16-byte KEK
/// Phase 2: AES-128-CBC/NoPadding(key=KEK, iv=b64url(key_field[2])).decrypt(b64url(key_field[1]))[..16]
fn derive_track_key(session_infos: &str, app_secret_hex: &str, key_field: &str) -> Result<[u8; 16]> {
fn derive_track_key(
session_infos: &str,
app_secret_hex: &str,
key_field: &str,
) -> Result<[u8; 16]> {
// Phase 1: HKDF
let infos_parts: Vec<&str> = session_infos.splitn(2, '.').collect();
if infos_parts.len() != 2 {
@@ -63,7 +67,11 @@ fn derive_track_key(session_infos: &str, app_secret_hex: &str, key_field: &str)
let ct = b64url_decode(key_parts[1])?;
let iv_bytes = b64url_decode(key_parts[2])?;
if ct.len() < 16 || iv_bytes.len() < 16 {
bail!("key field ciphertext/iv too short ({} / {} bytes)", ct.len(), iv_bytes.len());
bail!(
"key field ciphertext/iv too short ({} / {} bytes)",
ct.len(),
iv_bytes.len()
);
}
let iv: [u8; 16] = iv_bytes[..16].try_into()?;
@@ -202,7 +210,10 @@ impl QobuzClient {
let status = resp.status();
let body: Value = resp.json().await?;
if !status.is_success() {
let msg = body.get("message").and_then(|m| m.as_str()).unwrap_or("login failed");
let msg = body
.get("message")
.and_then(|m| m.as_str())
.unwrap_or("login failed");
bail!("login failed ({}): {}", status, msg);
}
@@ -238,9 +249,7 @@ impl QobuzClient {
}
let ts = Self::ts();
let mut sign_params: Vec<(&str, String)> = vec![
("profile", "qbz-1".to_string()),
];
let mut sign_params: Vec<(&str, String)> = vec![("profile", "qbz-1".to_string())];
let sig = self.request_sig("sessionstart", &mut sign_params, ts);
let resp = self
@@ -251,7 +260,10 @@ impl QobuzClient {
("request_ts", ts.to_string().as_str()),
("request_sig", sig.as_str()),
])
.header("Authorization", format!("Bearer {}", self.auth_token.as_deref().unwrap_or("")))
.header(
"Authorization",
format!("Bearer {}", self.auth_token.as_deref().unwrap_or("")),
)
.form(&[("profile", "qbz-1")])
.send()
.await?;
@@ -263,7 +275,12 @@ impl QobuzClient {
.to_string();
let expires_at = body["expires_at"].as_u64().unwrap_or(now + 3600);
let infos = body["infos"].as_str().map(|s| s.to_string());
eprintln!("[session] started session_id={}... expires_at={} infos={:?}", &session_id[..session_id.len().min(8)], expires_at, infos);
eprintln!(
"[session] started session_id={}... expires_at={} infos={:?}",
&session_id[..session_id.len().min(8)],
expires_at,
infos
);
self.session_id = Some(session_id);
self.session_expires_at = Some(expires_at);
self.session_infos = infos;
@@ -292,7 +309,11 @@ impl QobuzClient {
Ok(serde_json::from_value(body)?)
}
pub async fn get_track_url(&mut self, track_id: i64, format: Format) -> Result<TrackFileUrlDto> {
pub async fn get_track_url(
&mut self,
track_id: i64,
format: Format,
) -> Result<TrackFileUrlDto> {
self.ensure_session().await?;
let ts = Self::ts();
@@ -317,11 +338,15 @@ impl QobuzClient {
.await?;
let body = Self::check_response(resp).await?;
eprintln!("[file/url] response: {}", serde_json::to_string(&body).unwrap_or_default());
eprintln!(
"[file/url] response: {}",
serde_json::to_string(&body).unwrap_or_default()
);
let mut url_dto: TrackFileUrlDto = serde_json::from_value(body)?;
// Unwrap the per-track key: decrypt the CBC-wrapped key using HKDF-derived KEK.
if let (Some(key_field), Some(infos)) = (url_dto.key.clone(), self.session_infos.as_deref()) {
if let (Some(key_field), Some(infos)) = (url_dto.key.clone(), self.session_infos.as_deref())
{
match derive_track_key(infos, &self.app_secret, &key_field) {
Ok(track_key) => {
url_dto.key = Some(hex::encode(track_key));
@@ -370,12 +395,39 @@ impl QobuzClient {
let resp = self
.get_request("artist/getReleasesList")
.query(&[
("artist_id", artist_id.to_string()),
("artist_id", artist_id.to_string()),
("release_type", release_type.to_string()),
("sort", "release_date".to_string()),
("order", "desc".to_string()),
("limit", limit.to_string()),
("offset", offset.to_string()),
("sort", "release_date".to_string()),
("order", "desc".to_string()),
("limit", limit.to_string()),
("offset", offset.to_string()),
])
.send()
.await?;
Self::check_response(resp).await
}
// --- Browse ---
pub async fn get_genres(&self) -> Result<Value> {
let resp = self.get_request("genre/list").send().await?;
Self::check_response(resp).await
}
pub async fn get_featured_albums(
&self,
genre_id: i64,
kind: &str,
limit: u32,
offset: u32,
) -> Result<Value> {
let resp = self
.get_request("album/getFeatured")
.query(&[
("type", kind.to_string()),
("genre_id", genre_id.to_string()),
("limit", limit.to_string()),
("offset", offset.to_string()),
])
.send()
.await?;
@@ -384,54 +436,74 @@ impl QobuzClient {
// --- Search ---
pub async fn most_popular_search(&self, query: &str, limit: u32) -> Result<serde_json::Value> {
let resp = self
.get_request("most-popular/get")
.query(&[("query", query), ("offset", "0"), ("limit", &limit.to_string())])
.send()
.await?;
Self::check_response(resp).await
}
pub async fn search(&self, query: &str, offset: u32, limit: u32) -> Result<SearchCatalogDto> {
let (tracks, albums, artists) = tokio::try_join!(
let (tracks_res, albums_res, artists_res) = tokio::join!(
self.search_tracks(query, offset, limit),
self.search_albums(query, offset, limit),
self.search_artists(query, offset, limit),
)?;
);
// Convert successful Results into Some(value) and Errors into None
Ok(SearchCatalogDto {
query: Some(query.to_string()),
albums: Some(albums),
tracks: Some(tracks),
artists: Some(artists),
tracks: tracks_res.ok(),
albums: albums_res.ok(),
artists: artists_res.ok(),
playlists: None,
})
}
async fn search_tracks(&self, query: &str, offset: u32, limit: u32) -> Result<SearchResultItems<TrackDto>> {
async fn search_tracks(
&self,
query: &str,
offset: u32,
limit: u32,
) -> Result<SearchResultItems<TrackDto>> {
let resp = self
.get_request("track/search")
.query(&[("query", query), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
.query(&[
("query", query),
("offset", &offset.to_string()),
("limit", &limit.to_string()),
])
.send()
.await?;
let body = Self::check_response(resp).await?;
Ok(serde_json::from_value(body["tracks"].clone())?)
}
async fn search_albums(&self, query: &str, offset: u32, limit: u32) -> Result<SearchResultItems<AlbumDto>> {
async fn search_albums(
&self,
query: &str,
offset: u32,
limit: u32,
) -> Result<SearchResultItems<AlbumDto>> {
let resp = self
.get_request("album/search")
.query(&[("query", query), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
.query(&[
("query", query),
("offset", &offset.to_string()),
("limit", &limit.to_string()),
])
.send()
.await?;
let body = Self::check_response(resp).await?;
Ok(serde_json::from_value(body["albums"].clone())?)
}
async fn search_artists(&self, query: &str, offset: u32, limit: u32) -> Result<SearchResultItems<ArtistDto>> {
async fn search_artists(
&self,
query: &str,
offset: u32,
limit: u32,
) -> Result<SearchResultItems<ArtistDto>> {
let resp = self
.get_request("artist/search")
.query(&[("query", query), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
.query(&[
("query", query),
("offset", &offset.to_string()),
("limit", &limit.to_string()),
])
.send()
.await?;
let body = Self::check_response(resp).await?;
@@ -443,14 +515,22 @@ impl QobuzClient {
pub async fn get_user_playlists(&self, offset: u32, limit: u32) -> Result<UserPlaylistsDto> {
let resp = self
.get_request("playlist/getUserPlaylists")
.query(&[("offset", &offset.to_string()), ("limit", &limit.to_string())])
.query(&[
("offset", &offset.to_string()),
("limit", &limit.to_string()),
])
.send()
.await?;
let body = Self::check_response(resp).await?;
Ok(serde_json::from_value(body)?)
}
pub async fn get_playlist(&self, playlist_id: i64, offset: u32, limit: u32) -> Result<PlaylistDto> {
pub async fn get_playlist(
&self,
playlist_id: i64,
offset: u32,
limit: u32,
) -> Result<PlaylistDto> {
let resp = self
.get_request("playlist/get")
.query(&[
@@ -486,14 +566,16 @@ impl QobuzClient {
.send()
.await?;
let body = Self::check_response(resp).await?;
let items: Vec<TrackDto> = serde_json::from_value(
body["tracks"]["items"].clone(),
)
.unwrap_or_default();
let items: Vec<TrackDto> =
serde_json::from_value(body["tracks"]["items"].clone()).unwrap_or_default();
Ok(items)
}
pub async fn get_fav_tracks(&self, offset: u32, limit: u32) -> Result<SearchResultItems<TrackDto>> {
pub async fn get_fav_tracks(
&self,
offset: u32,
limit: u32,
) -> Result<SearchResultItems<TrackDto>> {
let ids = self.get_fav_ids().await?;
let all_ids = ids.tracks.unwrap_or_default();
let total = all_ids.len() as i32;
@@ -511,7 +593,11 @@ impl QobuzClient {
})
}
pub async fn get_fav_albums(&self, offset: u32, limit: u32) -> Result<SearchResultItems<AlbumDto>> {
pub async fn get_fav_albums(
&self,
offset: u32,
limit: u32,
) -> Result<SearchResultItems<AlbumDto>> {
let ids = self.get_fav_ids().await?;
let all_ids = ids.albums.unwrap_or_default();
let total = all_ids.len() as i32;
@@ -536,7 +622,11 @@ impl QobuzClient {
})
}
pub async fn get_fav_artists(&self, offset: u32, limit: u32) -> Result<SearchResultItems<FavArtistDto>> {
pub async fn get_fav_artists(
&self,
offset: u32,
limit: u32,
) -> Result<SearchResultItems<FavArtistDto>> {
let ids = self.get_fav_ids().await?;
let all_ids = ids.artists.unwrap_or_default();
let total = all_ids.len() as i32;
@@ -549,8 +639,40 @@ impl QobuzClient {
for artist_id in page {
match self.get_artist_page(artist_id).await {
Ok(v) => {
if let Ok(a) = serde_json::from_value::<FavArtistDto>(v) {
items.push(a);
let id = v.get("id").and_then(|i| i.as_i64());
let name = v
.get("name")
.and_then(|n| n.get("display"))
.and_then(|d| d.as_str())
.map(|s| s.to_string());
let mut image_dto = None;
if let Some(imgs) = v.get("images") {
if let Some(portrait) = imgs.get("portrait") {
if let (Some(hash), Some(format)) = (
portrait.get("hash").and_then(|h| h.as_str()),
portrait.get("format").and_then(|f| f.as_str()),
) {
image_dto = Some(ImageDto {
small: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
thumbnail: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
large: Some(format!("https://static.qobuz.com/images/artists/covers/large/{}.{}", hash, format)),
back: None,
});
}
}
}
if id.is_some() && name.is_some() {
items.push(FavArtistDto {
id,
name,
albums_count: v
.get("albums_count")
.and_then(|c| c.as_i64())
.map(|c| c as i32),
image: image_dto,
});
}
}
Err(e) => eprintln!("[fav] failed to fetch artist {}: {}", artist_id, e),
@@ -569,7 +691,11 @@ impl QobuzClient {
pub async fn create_playlist(&self, name: &str) -> Result<PlaylistDto> {
let resp = self
.post_request("playlist/create")
.form(&[("name", name), ("is_public", "false"), ("is_collaborative", "false")])
.form(&[
("name", name),
("is_public", "false"),
("is_collaborative", "false"),
])
.send()
.await?;
let body = Self::check_response(resp).await?;
@@ -581,7 +707,7 @@ impl QobuzClient {
.post_request("playlist/addTracks")
.form(&[
("playlist_id", playlist_id.to_string()),
("track_ids", track_id.to_string()),
("track_ids", track_id.to_string()),
("no_duplicate", "true".to_string()),
])
.send()
@@ -600,11 +726,15 @@ impl QobuzClient {
Ok(())
}
pub async fn delete_track_from_playlist(&self, playlist_id: i64, playlist_track_id: i64) -> Result<()> {
pub async fn delete_track_from_playlist(
&self,
playlist_id: i64,
playlist_track_id: i64,
) -> Result<()> {
let resp = self
.post_request("playlist/deleteTracks")
.form(&[
("playlist_id", playlist_id.to_string()),
("playlist_id", playlist_id.to_string()),
("playlist_track_ids", playlist_track_id.to_string()),
])
.send()

521
rust/src/lib.rs
View File

@@ -1,26 +1,4 @@
//! qobuz-backend: C-ABI library consumed by the Qt frontend.
//!
//! Event type constants – second argument of EventCallback:
//! 0 EV_LOGIN_OK { "token": "…", "user": { … } }
//! 1 EV_LOGIN_ERR { "error": "…" }
//! 2 EV_SEARCH_OK SearchCatalogDto
//! 3 EV_SEARCH_ERR { "error": "…" }
//! 4 EV_ALBUM_OK AlbumDto
//! 5 EV_ALBUM_ERR { "error": "…" }
//! 6 EV_ARTIST_OK ArtistDto
//! 7 EV_ARTIST_ERR { "error": "…" }
//! 8 EV_PLAYLIST_OK PlaylistDto
//! 9 EV_PLAYLIST_ERR { "error": "…" }
//! 10 EV_FAV_TRACKS_OK { "items": […], "total": N }
//! 11 EV_FAV_ALBUMS_OK { "items": […], "total": N }
//! 12 EV_FAV_ARTISTS_OK { "items": […], "total": N }
//! 13 EV_PLAYLISTS_OK { "items": […], "total": N }
//! 14 EV_TRACK_CHANGED TrackDto
//! 15 EV_STATE_CHANGED { "state": "playing"|"paused"|"idle"|"error" }
//! 16 EV_POSITION { "position": u64, "duration": u64 }
//! 17 EV_TRACK_URL_OK TrackFileUrlDto
//! 18 EV_TRACK_URL_ERR { "error": "…" }
//! 19 EV_GENERIC_ERR { "error": "…" }
mod api;
mod player;
@@ -38,9 +16,6 @@ use tokio::sync::Mutex;
// ---------- Send-safe raw pointer wrapper ----------
/// Wraps a `*mut c_void` so it can cross thread boundaries.
/// SAFETY: The Qt QobuzBackend object is kept alive for the Backend's lifetime
/// and callbacks only call QMetaObject::invokeMethod (thread-safe Qt API).
#[derive(Clone, Copy)]
struct SendPtr(*mut c_void);
unsafe impl Send for SendPtr {}
@@ -70,7 +45,8 @@ pub const EV_TRACK_URL_ERR: c_int = 18;
pub const EV_GENERIC_ERR: c_int = 19;
pub const EV_ARTIST_RELEASES_OK: c_int = 24;
pub const EV_DEEP_SHUFFLE_OK: c_int = 25;
pub const EV_MOST_POPULAR_OK: c_int = 26;
pub const EV_GENRES_OK: c_int = 27;
pub const EV_FEATURED_ALBUMS_OK: c_int = 28;
// ---------- Callback ----------
@@ -102,7 +78,6 @@ pub struct Backend(BackendInner);
// ---------- Helpers ----------
fn call_cb(cb: EventCallback, ud: SendPtr, ev: c_int, json: &str) {
// Strip null bytes that would cause CString::new to fail
let safe = json.replace('\0', "");
let cstr = CString::new(safe).unwrap_or_else(|_| CString::new("{}").unwrap());
unsafe { cb(ud.0, ev, cstr.as_ptr()) };
@@ -112,7 +87,6 @@ fn err_json(msg: &str) -> String {
serde_json::json!({ "error": msg }).to_string()
}
/// Spawn a Send + 'static future on the backend's Tokio runtime.
fn spawn<F>(inner: &BackendInner, f: F)
where
F: std::future::Future<Output = ()> + Send + 'static,
@@ -163,26 +137,33 @@ pub unsafe extern "C" fn qobuz_backend_login(
email: *const c_char,
password: *const c_char,
) {
let inner = &(*ptr).0;
let email = CStr::from_ptr(email).to_string_lossy().into_owned();
let inner = &(*ptr).0;
let email = CStr::from_ptr(email).to_string_lossy().into_owned();
let password = CStr::from_ptr(password).to_string_lossy().into_owned();
let client = inner.client.clone();
let cb = inner.cb;
let ud = inner.ud;
let client = inner.client.clone();
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.login(&email, &password).await;
let (ev, json) = match result {
Ok(resp) => {
let token = resp
.oauth2.as_ref().and_then(|o| o.access_token.as_deref())
.oauth2
.as_ref()
.and_then(|o| o.access_token.as_deref())
.or(resp.user_auth_token.as_deref())
.unwrap_or("")
.to_string();
let user_val = resp.user.as_ref()
let user_val = resp
.user
.as_ref()
.map(|u| serde_json::to_value(u).unwrap_or_default())
.unwrap_or_default();
(EV_LOGIN_OK, serde_json::json!({"token": token, "user": user_val}).to_string())
(
EV_LOGIN_OK,
serde_json::json!({"token": token, "user": user_val}).to_string(),
)
}
Err(e) => (EV_LOGIN_ERR, err_json(&e.to_string())),
};
@@ -194,8 +175,6 @@ pub unsafe extern "C" fn qobuz_backend_login(
pub unsafe extern "C" fn qobuz_backend_set_token(ptr: *mut Backend, token: *const c_char) {
let inner = &(*ptr).0;
let token = CStr::from_ptr(token).to_string_lossy().into_owned();
// Use blocking_lock (called from Qt main thread, not a tokio thread) so the
// token is set before any subsequent getUser/library requests are spawned.
inner.client.blocking_lock().set_auth_token(token);
}
@@ -207,27 +186,6 @@ pub unsafe extern "C" fn qobuz_backend_search(
query: *const c_char,
offset: u32,
limit: u32,
) {
let inner = &(*ptr).0;
let query = CStr::from_ptr(query).to_string_lossy().into_owned();
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.search(&query, offset, limit).await;
let (ev, json) = match result {
Ok(r) => (EV_SEARCH_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_SEARCH_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
});
}
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_most_popular_search(
ptr: *mut Backend,
query: *const c_char,
limit: u32,
) {
let inner = &(*ptr).0;
let query = CStr::from_ptr(query).to_string_lossy().into_owned();
@@ -236,10 +194,10 @@ pub unsafe extern "C" fn qobuz_backend_most_popular_search(
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.most_popular_search(&query, limit).await;
let result = client.lock().await.search(&query, offset, limit).await;
let (ev, json) = match result {
Ok(r) => (EV_MOST_POPULAR_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
Ok(r) => (EV_SEARCH_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_SEARCH_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
});
@@ -249,15 +207,16 @@ pub unsafe extern "C" fn qobuz_backend_most_popular_search(
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_get_album(ptr: *mut Backend, album_id: *const c_char) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let album_id = CStr::from_ptr(album_id).to_string_lossy().into_owned();
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_album(&album_id).await;
let (ev, json) = match result {
Ok(r) => (EV_ALBUM_OK, serde_json::to_string(&r).unwrap_or_default()),
Ok(r) => (EV_ALBUM_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_ALBUM_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
@@ -268,14 +227,15 @@ pub unsafe extern "C" fn qobuz_backend_get_album(ptr: *mut Backend, album_id: *c
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_get_artist(ptr: *mut Backend, artist_id: i64) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_artist_page(artist_id).await;
let (ev, json) = match result {
Ok(r) => (EV_ARTIST_OK, serde_json::to_string(&r).unwrap_or_default()),
Ok(r) => (EV_ARTIST_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_ARTIST_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
@@ -292,17 +252,19 @@ pub unsafe extern "C" fn qobuz_backend_get_artist_releases(
limit: u32,
_offset: u32,
) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
let rtype = CStr::from_ptr(release_type).to_string_lossy().into_owned();
spawn(inner, async move {
// Auto-paginate: fetch all pages until has_more is false.
let mut all_items: Vec<serde_json::Value> = Vec::new();
let mut offset: u32 = 0;
loop {
let result = client.lock().await
let result = client
.lock()
.await
.get_artist_releases_list(artist_id, &rtype, limit, offset)
.await;
match result {
@@ -311,7 +273,10 @@ pub unsafe extern "C" fn qobuz_backend_get_artist_releases(
if let Some(items) = obj.get("items").and_then(|v| v.as_array()) {
all_items.extend(items.iter().cloned());
}
let has_more = obj.get("has_more").and_then(|v| v.as_bool()).unwrap_or(false);
let has_more = obj
.get("has_more")
.and_then(|v| v.as_bool())
.unwrap_or(false);
if !has_more {
break;
}
@@ -329,7 +294,12 @@ pub unsafe extern "C" fn qobuz_backend_get_artist_releases(
"has_more": false,
"offset": 0
});
call_cb(cb, ud, EV_ARTIST_RELEASES_OK, &serde_json::to_string(&result).unwrap_or_default());
call_cb(
cb,
ud,
EV_ARTIST_RELEASES_OK,
&serde_json::to_string(&result).unwrap_or_default(),
);
});
}
@@ -342,8 +312,11 @@ pub unsafe extern "C" fn qobuz_backend_get_albums_tracks(
) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let ids_str = CStr::from_ptr(album_ids_json).to_string_lossy().into_owned();
let cb = inner.cb;
let ud = inner.ud;
let ids_str = CStr::from_ptr(album_ids_json)
.to_string_lossy()
.into_owned();
let album_ids: Vec<String> = match serde_json::from_str(&ids_str) {
Ok(v) => v,
@@ -360,17 +333,18 @@ pub unsafe extern "C" fn qobuz_backend_get_albums_tracks(
if let Ok(album) = result {
if let Some(tracks) = album.tracks.as_ref().and_then(|t| t.items.as_ref()) {
for t in tracks {
// Serialize track and inject album info for playback context
if let Ok(mut tv) = serde_json::to_value(t) {
if let Some(obj) = tv.as_object_mut() {
// Ensure album context is present on each track
if obj.get("album").is_none() || obj["album"].is_null() {
obj.insert("album".to_string(), serde_json::json!({
"id": album.id,
"title": album.title,
"artist": album.artist,
"image": album.image,
}));
obj.insert(
"album".to_string(),
serde_json::json!({
"id": album.id,
"title": album.title,
"artist": album.artist,
"image": album.image,
}),
);
}
}
all_tracks.push(tv);
@@ -378,10 +352,86 @@ pub unsafe extern "C" fn qobuz_backend_get_albums_tracks(
}
}
}
// Skip albums that fail — don't abort the whole operation
}
let result = serde_json::json!({ "tracks": all_tracks });
call_cb(cb, ud, EV_DEEP_SHUFFLE_OK, &serde_json::to_string(&result).unwrap_or_default());
call_cb(
cb,
ud,
EV_DEEP_SHUFFLE_OK,
&serde_json::to_string(&result).unwrap_or_default(),
);
});
}
// ---------- Playlist ----------
// ---------- Browse (genres / featured) ----------
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_get_genres(ptr: *mut Backend) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_genres().await;
match result {
Ok(r) => {
let items = r["genres"]["items"].clone();
let total = r["genres"]["total"].as_i64().unwrap_or(0);
let out = serde_json::json!({"items": items, "total": total});
call_cb(
cb,
ud,
EV_GENRES_OK,
&serde_json::to_string(&out).unwrap_or_default(),
);
}
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
}
});
}
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_get_featured_albums(
ptr: *mut Backend,
genre_id: i64,
kind: *const c_char,
limit: u32,
offset: u32,
) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb;
let ud = inner.ud;
let kind_str = CStr::from_ptr(kind).to_string_lossy().into_owned();
spawn(inner, async move {
let result = client
.lock()
.await
.get_featured_albums(genre_id, &kind_str, limit, offset)
.await;
match result {
Ok(r) => {
let items = r["albums"]["items"].clone();
let total = r["albums"]["total"].as_i64().unwrap_or(0);
let out = serde_json::json!({
"items": items,
"total": total,
"type": kind_str,
"genre_id": genre_id,
});
call_cb(
cb,
ud,
EV_FEATURED_ALBUMS_OK,
&serde_json::to_string(&out).unwrap_or_default(),
);
}
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
}
});
}
@@ -394,14 +444,22 @@ pub unsafe extern "C" fn qobuz_backend_get_playlist(
offset: u32,
limit: u32,
) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_playlist(playlist_id, offset, limit).await;
let result = client
.lock()
.await
.get_playlist(playlist_id, offset, limit)
.await;
let (ev, json) = match result {
Ok(r) => (EV_PLAYLIST_OK, serde_json::to_string(&r).unwrap_or_default()),
Ok(r) => (
EV_PLAYLIST_OK,
serde_json::to_string(&r).unwrap_or_default(),
),
Err(e) => (EV_PLAYLIST_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
@@ -414,12 +472,16 @@ pub unsafe extern "C" fn qobuz_backend_get_playlist(
pub unsafe extern "C" fn qobuz_backend_get_fav_tracks(ptr: *mut Backend, offset: u32, limit: u32) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_fav_tracks(offset, limit).await;
let (ev, json) = match result {
Ok(r) => (EV_FAV_TRACKS_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
Ok(r) => (
EV_FAV_TRACKS_OK,
serde_json::to_string(&r).unwrap_or_default(),
),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
});
@@ -429,12 +491,16 @@ pub unsafe extern "C" fn qobuz_backend_get_fav_tracks(ptr: *mut Backend, offset:
pub unsafe extern "C" fn qobuz_backend_get_fav_albums(ptr: *mut Backend, offset: u32, limit: u32) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_fav_albums(offset, limit).await;
let (ev, json) = match result {
Ok(r) => (EV_FAV_ALBUMS_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
Ok(r) => (
EV_FAV_ALBUMS_OK,
serde_json::to_string(&r).unwrap_or_default(),
),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
});
@@ -444,29 +510,46 @@ pub unsafe extern "C" fn qobuz_backend_get_fav_albums(ptr: *mut Backend, offset:
pub unsafe extern "C" fn qobuz_backend_get_fav_artists(ptr: *mut Backend, offset: u32, limit: u32) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_fav_artists(offset, limit).await;
let (ev, json) = match result {
Ok(r) => (EV_FAV_ARTISTS_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
Ok(r) => (
EV_FAV_ARTISTS_OK,
serde_json::to_string(&r).unwrap_or_default(),
),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
});
}
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_get_user_playlists(ptr: *mut Backend, offset: u32, limit: u32) {
pub unsafe extern "C" fn qobuz_backend_get_user_playlists(
ptr: *mut Backend,
offset: u32,
limit: u32,
) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_user_playlists(offset, limit).await;
let (ev, json) = match result {
Ok(r) => {
let items = r.playlists.as_ref().and_then(|p| p.items.as_ref()).cloned().unwrap_or_default();
let items = r
.playlists
.as_ref()
.and_then(|p| p.items.as_ref())
.cloned()
.unwrap_or_default();
let total = r.playlists.as_ref().and_then(|p| p.total).unwrap_or(0);
(EV_PLAYLISTS_OK, serde_json::json!({"items": items, "total": total}).to_string())
(
EV_PLAYLISTS_OK,
serde_json::json!({"items": items, "total": total}).to_string(),
)
}
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
};
@@ -482,9 +565,10 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
track_id: i64,
format_id: i32,
) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
let format = Format::from_id(format_id);
let cmd_tx = inner.player.cmd_tx.clone();
let status = inner.player.status.clone();
@@ -492,10 +576,13 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
let rg_enabled = inner.replaygain_enabled.clone();
spawn(inner, async move {
// 1. Check prefetch cache first for zero-gap start
let cached = {
let mut lock = prefetch.lock().await;
if lock.as_ref().map(|p| p.track_id == track_id).unwrap_or(false) {
if lock
.as_ref()
.map(|p| p.track_id == track_id)
.unwrap_or(false)
{
lock.take()
} else {
None
@@ -504,58 +591,71 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
// Extract prefetch_data to embed directly into TrackInfo
let (track, url, n_segments, encryption_key, prefetch_data) = if let Some(pf) = cached {
(pf.track, pf.url, pf.n_segments, pf.encryption_key, pf.prefetch_data)
(
pf.track,
pf.url,
pf.n_segments,
pf.encryption_key,
pf.prefetch_data,
)
} else {
// Fetch track metadata
let track = match client.lock().await.get_track(track_id).await {
Ok(t) => t,
Err(e) => { call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string())); return; }
Err(e) => {
call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string()));
return;
}
};
// Fetch stream URL
let url_dto = match client.lock().await.get_track_url(track_id, format).await {
Ok(u) => u,
Err(e) => { call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string())); return; }
Err(e) => {
call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json(&e.to_string()));
return;
}
};
let encryption_key = url_dto.key.clone();
// Prefer segmented url_template (reliable CDN path), fall back to plain url
eprintln!("[lib] url_dto: url={:?}, url_template={:?}, n_segments={:?}, mime={:?}, key_present={}",
url_dto.url.as_deref().map(|u| &u[..u.len().min(60)]),
url_dto.url_template.as_deref().map(|u| &u[..u.len().min(60)]),
url_dto.n_segments,
url_dto.mime_type,
encryption_key.is_some());
let (url, n_segments) = if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
(tmpl, n)
} else if let Some(u) = url_dto.url {
(u, 0u32)
} else {
call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json("no stream URL"));
return;
};
eprintln!("[lib] resolved: n_segments={n_segments}, url_prefix={}", &url[..url.len().min(80)]);
let (url, n_segments) =
if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
(tmpl, n)
} else if let Some(u) = url_dto.url {
(u, 0u32)
} else {
call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json("no stream URL"));
return;
};
(track, url, n_segments, encryption_key, None)
};
// 2. Notify track change
if let Ok(j) = serde_json::to_string(&track) {
call_cb(cb, ud, EV_TRACK_CHANGED, &j);
}
// 3. Compute ReplayGain if enabled
let replaygain_db = if rg_enabled.load(std::sync::atomic::Ordering::Relaxed) {
track.audio_info.as_ref().and_then(|ai| ai.replaygain_track_gain)
track
.audio_info
.as_ref()
.and_then(|ai| ai.replaygain_track_gain)
} else {
None
};
// 4. Update status + send play command
*status.current_track.lock().unwrap() = Some(track.clone());
if let Some(dur) = track.duration {
status.duration_secs.store(dur as u64, std::sync::atomic::Ordering::Relaxed);
status
.duration_secs
.store(dur as u64, std::sync::atomic::Ordering::Relaxed);
}
let _ = cmd_tx.send(player::PlayerCommand::Play(player::TrackInfo { track, url, n_segments, encryption_key, replaygain_db, prefetch_data }));
// 5. State notification
let _ = cmd_tx.send(player::PlayerCommand::Play(player::TrackInfo {
track,
url,
n_segments,
encryption_key,
replaygain_db,
prefetch_data,
}));
call_cb(cb, ud, EV_STATE_CHANGED, r#"{"state":"playing"}"#);
});
}
@@ -564,14 +664,24 @@ pub unsafe extern "C" fn qobuz_backend_play_track(
pub unsafe extern "C" fn qobuz_backend_pause(ptr: *mut Backend) {
let inner = &(*ptr).0;
inner.player.pause();
call_cb(inner.cb, inner.ud, EV_STATE_CHANGED, r#"{"state":"paused"}"#);
call_cb(
inner.cb,
inner.ud,
EV_STATE_CHANGED,
r#"{"state":"paused"}"#,
);
}
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_resume(ptr: *mut Backend) {
let inner = &(*ptr).0;
inner.player.resume();
call_cb(inner.cb, inner.ud, EV_STATE_CHANGED, r#"{"state":"playing"}"#);
call_cb(
inner.cb,
inner.ud,
EV_STATE_CHANGED,
r#"{"state":"playing"}"#,
);
}
#[no_mangle]
@@ -610,16 +720,24 @@ pub unsafe extern "C" fn qobuz_backend_get_volume(ptr: *const Backend) -> u8 {
pub unsafe extern "C" fn qobuz_backend_get_state(ptr: *const Backend) -> c_int {
match (*ptr).0.player.status.get_state() {
PlayerState::Playing => 1,
PlayerState::Paused => 2,
_ => 0,
PlayerState::Paused => 2,
_ => 0,
}
}
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_take_track_finished(ptr: *mut Backend) -> c_int {
let finished = (*ptr).0.player.status.track_finished
let finished = (*ptr)
.0
.player
.status
.track_finished
.swap(false, std::sync::atomic::Ordering::SeqCst);
if finished { 1 } else { 0 }
if finished {
1
} else {
0
}
}
#[no_mangle]
@@ -648,12 +766,20 @@ pub unsafe extern "C" fn qobuz_backend_take_track_transitioned(ptr: *mut Backend
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_set_replaygain(ptr: *mut Backend, enabled: bool) {
(*ptr).0.replaygain_enabled.store(enabled, std::sync::atomic::Ordering::Relaxed);
(*ptr)
.0
.replaygain_enabled
.store(enabled, std::sync::atomic::Ordering::Relaxed);
}
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_set_gapless(ptr: *mut Backend, enabled: bool) {
(*ptr).0.player.status.gapless.store(enabled, std::sync::atomic::Ordering::Relaxed);
(*ptr)
.0
.player
.status
.gapless
.store(enabled, std::sync::atomic::Ordering::Relaxed);
}
#[no_mangle]
@@ -678,13 +804,14 @@ pub unsafe extern "C" fn qobuz_backend_prefetch_track(
Err(_) => return,
};
let encryption_key = url_dto.key.clone();
let (url, n_segments) = if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
(tmpl, n)
} else if let Some(u) = url_dto.url {
(u, 0u32)
} else {
return;
};
let (url, n_segments) =
if let (Some(tmpl), Some(n)) = (url_dto.url_template, url_dto.n_segments) {
(tmpl, n)
} else if let Some(u) = url_dto.url {
(u, 0u32)
} else {
return;
};
// KICKSTART DOWNLOADING IMMEDIATELY
let prefetch_data = if n_segments > 0 {
@@ -699,7 +826,10 @@ pub unsafe extern "C" fn qobuz_backend_prefetch_track(
};
let replaygain_db = if rg_enabled.load(std::sync::atomic::Ordering::Relaxed) {
track.audio_info.as_ref().and_then(|ai| ai.replaygain_track_gain)
track
.audio_info
.as_ref()
.and_then(|ai| ai.replaygain_track_gain)
} else {
None
};
@@ -721,7 +851,8 @@ pub unsafe extern "C" fn qobuz_backend_prefetch_track(
pub unsafe extern "C" fn qobuz_backend_add_fav_track(ptr: *mut Backend, track_id: i64) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
if let Err(e) = client.lock().await.add_fav_track(track_id).await {
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -733,7 +864,8 @@ pub unsafe extern "C" fn qobuz_backend_add_fav_track(ptr: *mut Backend, track_id
pub unsafe extern "C" fn qobuz_backend_remove_fav_track(ptr: *mut Backend, track_id: i64) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
if let Err(e) = client.lock().await.remove_fav_track(track_id).await {
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -743,10 +875,11 @@ pub unsafe extern "C" fn qobuz_backend_remove_fav_track(ptr: *mut Backend, track
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_add_fav_album(ptr: *mut Backend, album_id: *const c_char) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let album_id = CStr::from_ptr(album_id).to_string_lossy().into_owned();
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
if let Err(e) = client.lock().await.add_fav_album(&album_id).await {
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -755,11 +888,15 @@ pub unsafe extern "C" fn qobuz_backend_add_fav_album(ptr: *mut Backend, album_id
}
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_remove_fav_album(ptr: *mut Backend, album_id: *const c_char) {
let inner = &(*ptr).0;
pub unsafe extern "C" fn qobuz_backend_remove_fav_album(
ptr: *mut Backend,
album_id: *const c_char,
) {
let inner = &(*ptr).0;
let album_id = CStr::from_ptr(album_id).to_string_lossy().into_owned();
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
if let Err(e) = client.lock().await.remove_fav_album(&album_id).await {
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -771,7 +908,8 @@ pub unsafe extern "C" fn qobuz_backend_remove_fav_album(ptr: *mut Backend, album
pub unsafe extern "C" fn qobuz_backend_add_fav_artist(ptr: *mut Backend, artist_id: i64) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
if let Err(e) = client.lock().await.add_fav_artist(artist_id).await {
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -783,7 +921,8 @@ pub unsafe extern "C" fn qobuz_backend_add_fav_artist(ptr: *mut Backend, artist_
pub unsafe extern "C" fn qobuz_backend_remove_fav_artist(ptr: *mut Backend, artist_id: i64) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
if let Err(e) = client.lock().await.remove_fav_artist(artist_id).await {
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
@@ -799,11 +938,12 @@ pub const EV_USER_OK: c_int = 23;
pub unsafe extern "C" fn qobuz_backend_get_user(ptr: *mut Backend) {
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
let result = client.lock().await.get_user().await;
let (ev, json) = match result {
Ok(r) => (EV_USER_OK, serde_json::to_string(&r).unwrap_or_default()),
Ok(r) => (EV_USER_OK, serde_json::to_string(&r).unwrap_or_default()),
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
};
call_cb(cb, ud, ev, &json);
@@ -819,12 +959,18 @@ pub const EV_PLAYLIST_TRACK_ADDED: c_int = 22;
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_create_playlist(ptr: *mut Backend, name: *const c_char) {
let inner = &(*ptr).0;
let name = CStr::from_ptr(name).to_string_lossy().into_owned();
let name = CStr::from_ptr(name).to_string_lossy().into_owned();
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
match client.lock().await.create_playlist(&name).await {
Ok(p) => call_cb(cb, ud, EV_PLAYLIST_CREATED, &serde_json::to_string(&p).unwrap_or_default()),
Ok(p) => call_cb(
cb,
ud,
EV_PLAYLIST_CREATED,
&serde_json::to_string(&p).unwrap_or_default(),
),
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
}
});
@@ -832,13 +978,18 @@ pub unsafe extern "C" fn qobuz_backend_create_playlist(ptr: *mut Backend, name:
#[no_mangle]
pub unsafe extern "C" fn qobuz_backend_delete_playlist(ptr: *mut Backend, playlist_id: i64) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
match client.lock().await.delete_playlist(playlist_id).await {
Ok(()) => call_cb(cb, ud, EV_PLAYLIST_DELETED,
&serde_json::json!({"playlist_id": playlist_id}).to_string()),
Ok(()) => call_cb(
cb,
ud,
EV_PLAYLIST_DELETED,
&serde_json::json!({"playlist_id": playlist_id}).to_string(),
),
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
}
});
@@ -850,13 +1001,23 @@ pub unsafe extern "C" fn qobuz_backend_add_track_to_playlist(
playlist_id: i64,
track_id: i64,
) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
match client.lock().await.add_track_to_playlist(playlist_id, track_id).await {
Ok(()) => call_cb(cb, ud, EV_PLAYLIST_TRACK_ADDED,
&serde_json::json!({"playlist_id": playlist_id}).to_string()),
match client
.lock()
.await
.add_track_to_playlist(playlist_id, track_id)
.await
{
Ok(()) => call_cb(
cb,
ud,
EV_PLAYLIST_TRACK_ADDED,
&serde_json::json!({"playlist_id": playlist_id}).to_string(),
),
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
}
});
@@ -868,11 +1029,17 @@ pub unsafe extern "C" fn qobuz_backend_delete_track_from_playlist(
playlist_id: i64,
playlist_track_id: i64,
) {
let inner = &(*ptr).0;
let inner = &(*ptr).0;
let client = inner.client.clone();
let cb = inner.cb; let ud = inner.ud;
let cb = inner.cb;
let ud = inner.ud;
spawn(inner, async move {
if let Err(e) = client.lock().await.delete_track_from_playlist(playlist_id, playlist_track_id).await {
if let Err(e) = client
.lock()
.await
.delete_track_from_playlist(playlist_id, playlist_track_id)
.await
{
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
}
});

6
rust/src/player/mod.rs
View File

@@ -141,7 +141,7 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
match rx.recv_timeout(Duration::from_millis(100)) {
Ok(PlayerCommand::Play(info)) => break info,
Ok(PlayerCommand::QueueNext(info)) => {
// If completely idle and get QueueNext, treat as Play
// If we are completely idle and get QueueNext, treat as Play
break info;
}
Ok(PlayerCommand::Stop) => {
@@ -155,7 +155,7 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
Ok(PlayerCommand::SetVolume(v)) => {
status.volume.store(v, Ordering::Relaxed);
}
Ok(_) => {}
Ok(_) => {} // Ignore Pause/Resume when idle
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => break 'outer,
}
@@ -176,9 +176,11 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
status.position_secs.store(0, Ordering::Relaxed);
paused.store(false, Ordering::SeqCst);
// TrackInfo now directly passes the prefetch_data (if it exists) to the decoder
match decoder::play_track_inline(info, &status, &paused, &mut audio_output, &rx) {
Ok(Some(NextAction::Play(next_track))) => {
pending_action = Some(NextAction::Play(next_track));
// Interrupted by a manual play, no need to tell C++ to advance the queue
}
Ok(Some(NextAction::Transition(next_track))) => {
pending_action = Some(NextAction::Play(next_track));

13
rust/src/player/output.rs
View File

@@ -3,7 +3,7 @@ use cpal::{
traits::{DeviceTrait, HostTrait, StreamTrait},
StreamConfig,
};
use rb::{RbConsumer, RbProducer, SpscRb, RB};
use rb::{RbConsumer, RbInspector, RbProducer, SpscRb, RB};
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
@@ -13,6 +13,7 @@ use symphonia::core::audio::AudioBufferRef;
const RING_BUFFER_SIZE: usize = 32 * 1024;
pub struct AudioOutput {
_ring: SpscRb<f32>,
ring_buf_producer: rb::Producer<f32>,
_stream: cpal::Stream,
pub sample_rate: u32,
@@ -50,6 +51,7 @@ impl AudioOutput {
stream.play()?;
Ok(Self {
_ring: ring,
ring_buf_producer: producer,
_stream: stream,
sample_rate,
@@ -87,4 +89,13 @@ impl AudioOutput {
}
Ok(())
}
pub fn flush(&self) {
// Wait until the ring buffer is fully emptied by cpal
while !self._ring.is_empty() {
std::thread::sleep(std::time::Duration::from_millis(10));
}
// Give the physical DAC an extra 100ms to output the last samples
std::thread::sleep(std::time::Duration::from_millis(100));
}
}