1303 lines
38 KiB
Rust
1303 lines
38 KiB
Rust
//! qobuz-backend: C-ABI library consumed by the Qt frontend.
|
|
#![allow(clippy::missing_safety_doc)]
|
|
|
|
mod api;
|
|
mod player;
|
|
|
|
use std::{
|
|
ffi::{CStr, CString},
|
|
os::raw::{c_char, c_int, c_void},
|
|
sync::Arc,
|
|
};
|
|
|
|
use api::{Format, QobuzClient};
|
|
use player::{Player, PlayerState};
|
|
use tokio::runtime::Runtime;
|
|
use tokio::sync::Mutex;
|
|
|
|
// ---------- Send-safe raw pointer wrapper ----------
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct SendPtr(*mut c_void);
|
|
unsafe impl Send for SendPtr {}
|
|
unsafe impl Sync for SendPtr {}
|
|
|
|
// ---------- Event type constants ----------
|
|
|
|
pub const EV_LOGIN_OK: c_int = 0;
|
|
pub const EV_LOGIN_ERR: c_int = 1;
|
|
pub const EV_SEARCH_OK: c_int = 2;
|
|
pub const EV_SEARCH_ERR: c_int = 3;
|
|
pub const EV_ALBUM_OK: c_int = 4;
|
|
pub const EV_ALBUM_ERR: c_int = 5;
|
|
pub const EV_ARTIST_OK: c_int = 6;
|
|
pub const EV_ARTIST_ERR: c_int = 7;
|
|
pub const EV_PLAYLIST_OK: c_int = 8;
|
|
pub const EV_PLAYLIST_ERR: c_int = 9;
|
|
pub const EV_FAV_TRACKS_OK: c_int = 10;
|
|
pub const EV_FAV_ALBUMS_OK: c_int = 11;
|
|
pub const EV_FAV_ARTISTS_OK: c_int = 12;
|
|
pub const EV_PLAYLISTS_OK: c_int = 13;
|
|
pub const EV_TRACK_CHANGED: c_int = 14;
|
|
pub const EV_STATE_CHANGED: c_int = 15;
|
|
pub const EV_POSITION: c_int = 16;
|
|
pub const EV_TRACK_URL_OK: c_int = 17;
|
|
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;
|
|
pub const EV_DYNAMIC_SUGGEST_OK: c_int = 29;
|
|
pub const EV_FEATURED_PLAYLISTS_OK: c_int = 30;
|
|
pub const EV_DISCOVER_PLAYLISTS_OK: c_int = 31;
|
|
pub const EV_PLAYLIST_SEARCH_OK: c_int = 32;
|
|
pub const EV_PLAYLIST_SUBSCRIBED: c_int = 33;
|
|
pub const EV_PLAYLIST_UNSUBSCRIBED: c_int = 34;
|
|
|
|
// ---------- Callback ----------
|
|
|
|
pub type EventCallback = unsafe extern "C" fn(*mut c_void, c_int, *const c_char);
|
|
|
|
// ---------- Backend ----------
|
|
|
|
struct PrefetchedTrack {
|
|
track_id: i64,
|
|
track: api::models::TrackDto,
|
|
url: String,
|
|
n_segments: u32,
|
|
encryption_key: Option<String>,
|
|
prefetch_data: Option<player::decoder::PrefetchData>,
|
|
}
|
|
|
|
struct BackendInner {
|
|
client: Arc<Mutex<QobuzClient>>,
|
|
player: Player,
|
|
rt: Runtime,
|
|
cb: EventCallback,
|
|
ud: SendPtr,
|
|
replaygain_enabled: std::sync::Arc<std::sync::atomic::AtomicBool>,
|
|
prefetch: std::sync::Arc<tokio::sync::Mutex<Option<PrefetchedTrack>>>,
|
|
}
|
|
|
|
pub struct Backend(BackendInner);
|
|
|
|
// ---------- Helpers ----------
|
|
|
|
fn call_cb(cb: EventCallback, ud: SendPtr, ev: c_int, json: &str) {
|
|
let safe = json.replace('\0', "");
|
|
let cstr = CString::new(safe).unwrap_or_else(|_| CString::new("{}").unwrap());
|
|
unsafe { cb(ud.0, ev, cstr.as_ptr()) };
|
|
}
|
|
|
|
fn err_json(msg: &str) -> String {
|
|
serde_json::json!({ "error": msg }).to_string()
|
|
}
|
|
|
|
fn spawn<F>(inner: &BackendInner, f: F)
|
|
where
|
|
F: std::future::Future<Output = ()> + Send + 'static,
|
|
{
|
|
inner.rt.spawn(f);
|
|
}
|
|
|
|
// ---------- Construction / destruction ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_new(
|
|
event_cb: EventCallback,
|
|
userdata: *mut c_void,
|
|
) -> *mut Backend {
|
|
let rt = match Runtime::new() {
|
|
Ok(r) => r,
|
|
Err(_) => return std::ptr::null_mut(),
|
|
};
|
|
let client = match QobuzClient::new() {
|
|
Ok(c) => Arc::new(Mutex::new(c)),
|
|
Err(_) => return std::ptr::null_mut(),
|
|
};
|
|
let player = Player::new();
|
|
|
|
Box::into_raw(Box::new(Backend(BackendInner {
|
|
client,
|
|
player,
|
|
rt,
|
|
cb: event_cb,
|
|
ud: SendPtr(userdata),
|
|
replaygain_enabled: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
|
|
prefetch: std::sync::Arc::new(tokio::sync::Mutex::new(None)),
|
|
})))
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_free(ptr: *mut Backend) {
|
|
if !ptr.is_null() {
|
|
drop(Box::from_raw(ptr));
|
|
}
|
|
}
|
|
|
|
// ---------- Auth ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_login(
|
|
ptr: *mut Backend,
|
|
email: *const c_char,
|
|
password: *const c_char,
|
|
) {
|
|
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;
|
|
|
|
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())
|
|
.or(resp.user_auth_token.as_deref())
|
|
.unwrap_or("")
|
|
.to_string();
|
|
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(),
|
|
)
|
|
}
|
|
Err(e) => (EV_LOGIN_ERR, err_json(&e.to_string())),
|
|
};
|
|
call_cb(cb, ud, ev, &json);
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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();
|
|
inner.client.blocking_lock().set_auth_token(token);
|
|
}
|
|
|
|
// ---------- Search ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_search(
|
|
ptr: *mut Backend,
|
|
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();
|
|
let client = inner.client.clone();
|
|
let cb = inner.cb;
|
|
let ud = inner.ud;
|
|
|
|
spawn(inner, async move {
|
|
let result = client
|
|
.lock()
|
|
.await
|
|
.get_most_popular(&query, 0, limit)
|
|
.await;
|
|
match result {
|
|
Ok(r) => call_cb(
|
|
cb,
|
|
ud,
|
|
EV_MOST_POPULAR_OK,
|
|
&serde_json::to_string(&r).unwrap_or_default(),
|
|
),
|
|
Err(e) => call_cb(cb, ud, EV_SEARCH_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_dynamic_suggestions(
|
|
ptr: *mut Backend,
|
|
listened_track_ids_json: *const c_char,
|
|
tracks_to_analyze_json: *const c_char,
|
|
limit: u32,
|
|
) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
let cb = inner.cb;
|
|
let ud = inner.ud;
|
|
|
|
let listened_str = CStr::from_ptr(listened_track_ids_json)
|
|
.to_string_lossy()
|
|
.into_owned();
|
|
let analyze_str = CStr::from_ptr(tracks_to_analyze_json)
|
|
.to_string_lossy()
|
|
.into_owned();
|
|
|
|
let listened: serde_json::Value = match serde_json::from_str(&listened_str) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
|
|
return;
|
|
}
|
|
};
|
|
|
|
let to_analyze: serde_json::Value = match serde_json::from_str(&analyze_str) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
|
|
return;
|
|
}
|
|
};
|
|
|
|
spawn(inner, async move {
|
|
let result = client
|
|
.lock()
|
|
.await
|
|
.get_dynamic_suggestions(limit, listened, to_analyze)
|
|
.await;
|
|
match result {
|
|
Ok(r) => call_cb(
|
|
cb,
|
|
ud,
|
|
EV_DYNAMIC_SUGGEST_OK,
|
|
&serde_json::to_string(&r).unwrap_or_default(),
|
|
),
|
|
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|
|
|
|
// ---------- Album ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_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;
|
|
|
|
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()),
|
|
Err(e) => (EV_ALBUM_ERR, err_json(&e.to_string())),
|
|
};
|
|
call_cb(cb, ud, ev, &json);
|
|
});
|
|
}
|
|
|
|
// ---------- Artist ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_artist(ptr: *mut Backend, artist_id: i64) {
|
|
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_artist_page(artist_id).await;
|
|
let (ev, json) = match result {
|
|
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);
|
|
});
|
|
}
|
|
|
|
// ---------- Artist releases ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_artist_releases(
|
|
ptr: *mut Backend,
|
|
artist_id: i64,
|
|
release_type: *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 rtype = CStr::from_ptr(release_type).to_string_lossy().into_owned();
|
|
|
|
spawn(inner, async move {
|
|
let mut all_items: Vec<serde_json::Value> = Vec::new();
|
|
let mut offset: u32 = 0;
|
|
loop {
|
|
let result = client
|
|
.lock()
|
|
.await
|
|
.get_artist_releases_list(artist_id, &rtype, limit, offset)
|
|
.await;
|
|
match result {
|
|
Ok(r) => {
|
|
let obj = r.as_object().cloned().unwrap_or_default();
|
|
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);
|
|
if !has_more {
|
|
break;
|
|
}
|
|
offset += limit;
|
|
}
|
|
Err(e) => {
|
|
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
let result = serde_json::json!({
|
|
"release_type": rtype,
|
|
"items": all_items,
|
|
"has_more": false,
|
|
"offset": 0
|
|
});
|
|
call_cb(
|
|
cb,
|
|
ud,
|
|
EV_ARTIST_RELEASES_OK,
|
|
&serde_json::to_string(&result).unwrap_or_default(),
|
|
);
|
|
});
|
|
}
|
|
|
|
// ---------- Deep shuffle (fetch tracks from multiple albums) ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_albums_tracks(
|
|
ptr: *mut Backend,
|
|
album_ids_json: *const c_char,
|
|
) {
|
|
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 album_ids: Vec<String> = match serde_json::from_str(&ids_str) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
|
|
return;
|
|
}
|
|
};
|
|
|
|
spawn(inner, async move {
|
|
let mut all_tracks: Vec<serde_json::Value> = Vec::new();
|
|
for id in &album_ids {
|
|
let result = client.lock().await.get_album(id).await;
|
|
if let Ok(album) = result {
|
|
if let Some(tracks) = album.tracks.as_ref().and_then(|t| t.items.as_ref()) {
|
|
for t in tracks {
|
|
if let Ok(mut tv) = serde_json::to_value(t) {
|
|
if let Some(obj) = tv.as_object_mut() {
|
|
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,
|
|
}),
|
|
);
|
|
}
|
|
}
|
|
all_tracks.push(tv);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let result = serde_json::json!({ "tracks": all_tracks });
|
|
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_ids: *const c_char,
|
|
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 genre_ids_str = CStr::from_ptr(genre_ids).to_string_lossy().into_owned();
|
|
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_ids_str, &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_ids": genre_ids_str,
|
|
});
|
|
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())),
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_featured_playlists(
|
|
ptr: *mut Backend,
|
|
genre_ids: *const c_char,
|
|
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();
|
|
let genre_ids_str = CStr::from_ptr(genre_ids).to_string_lossy().into_owned();
|
|
|
|
spawn(inner, async move {
|
|
let result = client
|
|
.lock()
|
|
.await
|
|
.get_featured_playlists(&genre_ids_str, &kind_str, limit, offset)
|
|
.await;
|
|
match result {
|
|
Ok(r) => {
|
|
let items = r["playlists"]["items"].clone();
|
|
let total = r["playlists"]["total"].as_i64().unwrap_or(0);
|
|
let out = serde_json::json!({
|
|
"items": items,
|
|
"total": total,
|
|
"type": kind_str,
|
|
"genre_ids": genre_ids_str,
|
|
});
|
|
call_cb(
|
|
cb,
|
|
ud,
|
|
EV_FEATURED_PLAYLISTS_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_discover_playlists(
|
|
ptr: *mut Backend,
|
|
genre_ids: *const c_char,
|
|
tags: *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 genre_ids_str = CStr::from_ptr(genre_ids).to_string_lossy().into_owned();
|
|
let tags_str = CStr::from_ptr(tags).to_string_lossy().into_owned();
|
|
|
|
spawn(inner, async move {
|
|
let result = client
|
|
.lock()
|
|
.await
|
|
.discover_playlists(&genre_ids_str, &tags_str, limit, offset)
|
|
.await;
|
|
match result {
|
|
Ok(r) => {
|
|
let items = r["items"].clone();
|
|
let total = r["total"].as_i64().unwrap_or(0);
|
|
let out = serde_json::json!({
|
|
"items": items,
|
|
"total": total,
|
|
"genre_ids": genre_ids_str,
|
|
"tags": tags_str,
|
|
});
|
|
call_cb(
|
|
cb,
|
|
ud,
|
|
EV_DISCOVER_PLAYLISTS_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_search_playlists(
|
|
ptr: *mut Backend,
|
|
query: *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 query_str = CStr::from_ptr(query).to_string_lossy().into_owned();
|
|
|
|
spawn(inner, async move {
|
|
let result = client
|
|
.lock()
|
|
.await
|
|
.search_playlists(&query_str, limit, offset)
|
|
.await;
|
|
match result {
|
|
Ok(r) => {
|
|
let items = r["playlists"]["items"].clone();
|
|
let total = r["playlists"]["total"].as_i64().unwrap_or(0);
|
|
let out = serde_json::json!({
|
|
"items": items,
|
|
"total": total,
|
|
"query": query_str,
|
|
});
|
|
call_cb(
|
|
cb,
|
|
ud,
|
|
EV_PLAYLIST_SEARCH_OK,
|
|
&serde_json::to_string(&out).unwrap_or_default(),
|
|
);
|
|
}
|
|
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|
|
|
|
// ---------- Playlist ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_playlist(
|
|
ptr: *mut Backend,
|
|
playlist_id: i64,
|
|
offset: u32,
|
|
limit: u32,
|
|
) {
|
|
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_playlist(playlist_id, offset, limit)
|
|
.await;
|
|
let (ev, json) = match result {
|
|
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);
|
|
});
|
|
}
|
|
|
|
// ---------- Favorites ----------
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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())),
|
|
};
|
|
call_cb(cb, ud, ev, &json);
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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())),
|
|
};
|
|
call_cb(cb, ud, ev, &json);
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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())),
|
|
};
|
|
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,
|
|
) {
|
|
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_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 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(),
|
|
)
|
|
}
|
|
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
|
|
};
|
|
call_cb(cb, ud, ev, &json);
|
|
});
|
|
}
|
|
|
|
// ---------- Playback ----------
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_play_track(
|
|
ptr: *mut Backend,
|
|
track_id: i64,
|
|
format_id: i32,
|
|
) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
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();
|
|
let prefetch = inner.prefetch.clone();
|
|
let rg_enabled = inner.replaygain_enabled.clone();
|
|
|
|
spawn(inner, async move {
|
|
let cached = {
|
|
let mut lock = prefetch.lock().await;
|
|
if lock
|
|
.as_ref()
|
|
.map(|p| p.track_id == track_id)
|
|
.unwrap_or(false)
|
|
{
|
|
lock.take()
|
|
} else {
|
|
None
|
|
}
|
|
};
|
|
|
|
// 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,
|
|
)
|
|
} else {
|
|
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;
|
|
}
|
|
};
|
|
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;
|
|
}
|
|
};
|
|
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 {
|
|
call_cb(cb, ud, EV_TRACK_URL_ERR, &err_json("no stream URL"));
|
|
return;
|
|
};
|
|
(track, url, n_segments, encryption_key, None)
|
|
};
|
|
|
|
if let Ok(j) = serde_json::to_string(&track) {
|
|
call_cb(cb, ud, EV_TRACK_CHANGED, &j);
|
|
}
|
|
|
|
let replaygain_db = if rg_enabled.load(std::sync::atomic::Ordering::Relaxed) {
|
|
track
|
|
.audio_info
|
|
.as_ref()
|
|
.and_then(|ai| ai.replaygain_track_gain)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
*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);
|
|
}
|
|
|
|
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"}"#);
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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"}"#,
|
|
);
|
|
}
|
|
|
|
#[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"}"#,
|
|
);
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_stop(ptr: *mut Backend) {
|
|
let inner = &(*ptr).0;
|
|
inner.player.stop();
|
|
call_cb(inner.cb, inner.ud, EV_STATE_CHANGED, r#"{"state":"idle"}"#);
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_set_volume(ptr: *mut Backend, volume: u8) {
|
|
(*ptr).0.player.set_volume(volume);
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_seek(ptr: *mut Backend, position_secs: u64) {
|
|
(*ptr).0.player.seek(position_secs);
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_position(ptr: *const Backend) -> u64 {
|
|
(*ptr).0.player.status.get_position()
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_duration(ptr: *const Backend) -> u64 {
|
|
(*ptr).0.player.status.get_duration()
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_get_volume(ptr: *const Backend) -> u8 {
|
|
(*ptr).0.player.status.get_volume()
|
|
}
|
|
|
|
#[no_mangle]
|
|
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,
|
|
}
|
|
}
|
|
|
|
#[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
|
|
.swap(false, std::sync::atomic::Ordering::SeqCst);
|
|
if finished {
|
|
1
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_take_track_transitioned(ptr: *mut Backend) -> c_int {
|
|
let inner = &(*ptr).0;
|
|
let transitioned = inner
|
|
.player
|
|
.status
|
|
.track_transitioned
|
|
.swap(false, std::sync::atomic::Ordering::SeqCst);
|
|
|
|
if transitioned {
|
|
// Emit track changed so the Qt UI and Scrobbler automatically pick up the new song
|
|
if let Some(track) = inner.player.status.current_track.lock().unwrap().as_ref() {
|
|
if let Ok(j) = serde_json::to_string(track) {
|
|
call_cb(inner.cb, inner.ud, EV_TRACK_CHANGED, &j);
|
|
}
|
|
}
|
|
1
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
// ---------- ReplayGain / Gapless ----------
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_prefetch_track(
|
|
ptr: *mut Backend,
|
|
track_id: i64,
|
|
format_id: i32,
|
|
) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
let format = Format::from_id(format_id);
|
|
let cmd_tx = inner.player.cmd_tx.clone();
|
|
let rg_enabled = inner.replaygain_enabled.clone();
|
|
|
|
spawn(inner, async move {
|
|
let track = match client.lock().await.get_track(track_id).await {
|
|
Ok(t) => t,
|
|
Err(_) => return,
|
|
};
|
|
let url_dto = match client.lock().await.get_track_url(track_id, format).await {
|
|
Ok(u) => u,
|
|
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;
|
|
};
|
|
|
|
// KICKSTART DOWNLOADING IMMEDIATELY
|
|
let prefetch_data = if n_segments > 0 {
|
|
Some(player::decoder::start_prefetch(
|
|
url.clone(),
|
|
n_segments,
|
|
encryption_key.as_deref(),
|
|
1,
|
|
))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let replaygain_db = if rg_enabled.load(std::sync::atomic::Ordering::Relaxed) {
|
|
track
|
|
.audio_info
|
|
.as_ref()
|
|
.and_then(|ai| ai.replaygain_track_gain)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let _ = cmd_tx.send(player::PlayerCommand::QueueNext(player::TrackInfo {
|
|
track,
|
|
url,
|
|
n_segments,
|
|
encryption_key,
|
|
replaygain_db,
|
|
prefetch_data,
|
|
}));
|
|
});
|
|
}
|
|
|
|
// ---------- Favorites modification ----------
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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()));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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()));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[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 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;
|
|
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()));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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()));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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()));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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()));
|
|
}
|
|
});
|
|
}
|
|
|
|
// ---------- User ----------
|
|
|
|
pub const EV_USER_OK: c_int = 23;
|
|
|
|
#[no_mangle]
|
|
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;
|
|
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()),
|
|
Err(e) => (EV_GENERIC_ERR, err_json(&e.to_string())),
|
|
};
|
|
call_cb(cb, ud, ev, &json);
|
|
});
|
|
}
|
|
|
|
// ---------- Playlist management ----------
|
|
|
|
pub const EV_PLAYLIST_CREATED: c_int = 20;
|
|
pub const EV_PLAYLIST_DELETED: c_int = 21;
|
|
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 client = inner.client.clone();
|
|
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(),
|
|
),
|
|
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_delete_playlist(ptr: *mut Backend, playlist_id: i64) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
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(),
|
|
),
|
|
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_add_track_to_playlist(
|
|
ptr: *mut Backend,
|
|
playlist_id: i64,
|
|
track_id: i64,
|
|
) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
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(),
|
|
),
|
|
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_delete_track_from_playlist(
|
|
ptr: *mut Backend,
|
|
playlist_id: i64,
|
|
playlist_track_id: i64,
|
|
) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
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
|
|
{
|
|
call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string()));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_subscribe_playlist(ptr: *mut Backend, playlist_id: i64) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
let cb = inner.cb;
|
|
let ud = inner.ud;
|
|
spawn(inner, async move {
|
|
match client.lock().await.subscribe_playlist(playlist_id).await {
|
|
Ok(()) => call_cb(
|
|
cb,
|
|
ud,
|
|
EV_PLAYLIST_SUBSCRIBED,
|
|
&serde_json::json!({"playlist_id": playlist_id}).to_string(),
|
|
),
|
|
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn qobuz_backend_unsubscribe_playlist(ptr: *mut Backend, playlist_id: i64) {
|
|
let inner = &(*ptr).0;
|
|
let client = inner.client.clone();
|
|
let cb = inner.cb;
|
|
let ud = inner.ud;
|
|
spawn(inner, async move {
|
|
match client.lock().await.unsubscribe_playlist(playlist_id).await {
|
|
Ok(()) => call_cb(
|
|
cb,
|
|
ud,
|
|
EV_PLAYLIST_UNSUBSCRIBED,
|
|
&serde_json::json!({"playlist_id": playlist_id}).to_string(),
|
|
),
|
|
Err(e) => call_cb(cb, ud, EV_GENERIC_ERR, &err_json(&e.to_string())),
|
|
}
|
|
});
|
|
}
|